// $ANTLR 3.1.2 D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g 2009-05-22 11:27:33

	using System.Collections.Generic;
	using System.Drawing;


import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;
import org.antlr.runtime.debug.*;
import java.io.IOException;
public class GrammaireZ2EnuParser extends DebugParser {
    public static final String[] tokenNames = new String[] {
        "<invalid>", "<EOR>", "<DOWN>", "<UP>", "ID", "Sep", "Types", "CSTE", "Autres", "Proc26", "Proc53", "Proc50", "Proc39", "Proc30", "Opr", "Opm", "STRING", "WS", "COMMENT", "'begin'", "'end'", "';'", "'action'", "'('", "')'", "'function'", "':'", "'dynamic'", "'pointer'", "'to'", "'of'", "'file'", "'vector'", "'header'", "','", "'buffer'", "'structure'", "'arm'", "':='", "'tantque'", "'endwhile'", "'ewhile'", "'if'", "'else'", "'endif'", "'eif'", "'for'", "'endfor'", "'efor'", "'call'", "'read'", "'write'", "'open'", "'ass_item'", "'['", "']'", "'+'", "'-'", "'or'", "'nil'", "'not'", "'true'", "'false'", "'item'", "'left_son'", "'rigth_son'", "'father'", "'info'", "'value'", "'next'", "'previous'", "'queue_empty'", "'stack_empty'", "'degree'", "'length'", "'alea_string'", "'alea_number'", "'alloc_bloc'", "'end_file'", "'son'", "'infor'", "'mod'", "'min'", "'max'", "'struct'", "'charact'", "'exp'", "'definition'", "'definitions'"
    };
    public static final int Types=6;
    public static final int T__68=68;
    public static final int T__69=69;
    public static final int T__66=66;
    public static final int T__67=67;
    public static final int CSTE=7;
    public static final int T__64=64;
    public static final int T__29=29;
    public static final int T__65=65;
    public static final int T__28=28;
    public static final int T__62=62;
    public static final int T__27=27;
    public static final int Opr=14;
    public static final int T__63=63;
    public static final int T__26=26;
    public static final int T__25=25;
    public static final int T__24=24;
    public static final int T__23=23;
    public static final int T__22=22;
    public static final int T__21=21;
    public static final int T__20=20;
    public static final int ID=4;
    public static final int T__61=61;
    public static final int Proc50=11;
    public static final int T__60=60;
    public static final int EOF=-1;
    public static final int Opm=15;
    public static final int Proc53=10;
    public static final int T__55=55;
    public static final int T__19=19;
    public static final int T__56=56;
    public static final int T__57=57;
    public static final int T__58=58;
    public static final int T__51=51;
    public static final int T__52=52;
    public static final int T__53=53;
    public static final int T__54=54;
    public static final int T__59=59;
    public static final int COMMENT=18;
    public static final int Proc26=9;
    public static final int T__50=50;
    public static final int T__42=42;
    public static final int T__43=43;
    public static final int T__40=40;
    public static final int T__41=41;
    public static final int T__80=80;
    public static final int T__46=46;
    public static final int T__81=81;
    public static final int T__47=47;
    public static final int T__82=82;
    public static final int T__44=44;
    public static final int T__83=83;
    public static final int T__45=45;
    public static final int T__48=48;
    public static final int T__49=49;
    public static final int Proc30=13;
    public static final int T__85=85;
    public static final int Proc39=12;
    public static final int T__84=84;
    public static final int T__87=87;
    public static final int T__86=86;
    public static final int T__88=88;
    public static final int Sep=5;
    public static final int T__30=30;
    public static final int T__31=31;
    public static final int T__32=32;
    public static final int WS=17;
    public static final int T__71=71;
    public static final int T__33=33;
    public static final int Autres=8;
    public static final int T__72=72;
    public static final int T__34=34;
    public static final int T__35=35;
    public static final int T__70=70;
    public static final int T__36=36;
    public static final int T__37=37;
    public static final int T__38=38;
    public static final int T__39=39;
    public static final int T__76=76;
    public static final int T__75=75;
    public static final int T__74=74;
    public static final int T__73=73;
    public static final int T__79=79;
    public static final int STRING=16;
    public static final int T__78=78;
    public static final int T__77=77;

    // delegates
    // delegators

    public static final String[] ruleNames = new String[] {
        "invalidRule", "synpred69_GrammaireZ2Enu", "inst", "synpred65_GrammaireZ2Enu", 
        "synpred85_GrammaireZ2Enu", "synpred90_GrammaireZ2Enu", "synpred55_GrammaireZ2Enu", 
        "synpred27_GrammaireZ2Enu", "synpred121_GrammaireZ2Enu", "synpred5_GrammaireZ2Enu", 
        "strucrcomplexe", "synpred42_GrammaireZ2Enu", "synpred46_GrammaireZ2Enu", 
        "synpred39_GrammaireZ2Enu", "synpred127_GrammaireZ2Enu", "synpred107_GrammaireZ2Enu", 
        "synpred26_GrammaireZ2Enu", "synpred75_GrammaireZ2Enu", "algoz", 
        "synpred51_GrammaireZ2Enu", "synpred97_GrammaireZ2Enu", "synpred18_GrammaireZ2Enu", 
        "synpred125_GrammaireZ2Enu", "synpred116_GrammaireZ2Enu", "facteur", 
        "synpred82_GrammaireZ2Enu", "synpred94_GrammaireZ2Enu", "synpred92_GrammaireZ2Enu", 
        "synpred87_GrammaireZ2Enu", "synpred4_GrammaireZ2Enu", "synpred110_GrammaireZ2Enu", 
        "synpred48_GrammaireZ2Enu", "lis", "synpred20_GrammaireZ2Enu", "synpred108_GrammaireZ2Enu", 
        "synpred128_GrammaireZ2Enu", "synpred109_GrammaireZ2Enu", "synpred23_GrammaireZ2Enu", 
        "synpred40_GrammaireZ2Enu", "synpred122_GrammaireZ2Enu", "synpred119_GrammaireZ2Enu", 
        "synpred15_GrammaireZ2Enu", "definition", "synpred112_GrammaireZ2Enu", 
        "synpred1_GrammaireZ2Enu", "fanct", "synpred9_GrammaireZ2Enu", "fonct27", 
        "synpred114_GrammaireZ2Enu", "synpred72_GrammaireZ2Enu", "synpred77_GrammaireZ2Enu", 
        "fonct34", "synpred32_GrammaireZ2Enu", "synpred83_GrammaireZ2Enu", 
        "synpred115_GrammaireZ2Enu", "typecomp", "synpred44_GrammaireZ2Enu", 
        "synpred58_GrammaireZ2Enu", "synpred113_GrammaireZ2Enu", "synpred86_GrammaireZ2Enu", 
        "synpred3_GrammaireZ2Enu", "ps", "synpred10_GrammaireZ2Enu", "synpred105_GrammaireZ2Enu", 
        "synpred104_GrammaireZ2Enu", "synpred61_GrammaireZ2Enu", "synpred35_GrammaireZ2Enu", 
        "synpred120_GrammaireZ2Enu", "synpred99_GrammaireZ2Enu", "synpred78_GrammaireZ2Enu", 
        "synpred56_GrammaireZ2Enu", "synpred2_GrammaireZ2Enu", "structsimple", 
        "synpred79_GrammaireZ2Enu", "synpred81_GrammaireZ2Enu", "synpred84_GrammaireZ2Enu", 
        "synpred64_GrammaireZ2Enu", "synpred13_GrammaireZ2Enu", "synpred71_GrammaireZ2Enu", 
        "lisIngnorebeing", "synpred76_GrammaireZ2Enu", "program", "synpred70_GrammaireZ2Enu", 
        "synpred130_GrammaireZ2Enu", "synpred19_GrammaireZ2Enu", "synpred25_GrammaireZ2Enu", 
        "synpred52_GrammaireZ2Enu", "synpred41_GrammaireZ2Enu", "synpred98_GrammaireZ2Enu", 
        "synpred8_GrammaireZ2Enu", "synpred54_GrammaireZ2Enu", "synpred31_GrammaireZ2Enu", 
        "synpred68_GrammaireZ2Enu", "synpred33_GrammaireZ2Enu", "synpred7_GrammaireZ2Enu", 
        "synpred14_GrammaireZ2Enu", "synpred22_GrammaireZ2Enu", "li", "synpred11_GrammaireZ2Enu", 
        "synpred36_GrammaireZ2Enu", "synpred100_GrammaireZ2Enu", "s", "exp", 
        "terme", "fonct32", "synpred63_GrammaireZ2Enu", "synpred103_GrammaireZ2Enu", 
        "synpred89_GrammaireZ2Enu", "synpred60_GrammaireZ2Enu", "synpred16_GrammaireZ2Enu", 
        "synpred126_GrammaireZ2Enu", "synpred34_GrammaireZ2Enu", "synpred47_GrammaireZ2Enu", 
        "listecste", "synpred118_GrammaireZ2Enu", "synpred74_GrammaireZ2Enu", 
        "synpred30_GrammaireZ2Enu", "synpred102_GrammaireZ2Enu", "fonct57", 
        "synpred50_GrammaireZ2Enu", "synpred24_GrammaireZ2Enu", "synpred106_GrammaireZ2Enu", 
        "synpred6_GrammaireZ2Enu", "synpred17_GrammaireZ2Enu", "synpred96_GrammaireZ2Enu", 
        "synpred124_GrammaireZ2Enu", "synpred101_GrammaireZ2Enu", "synpred123_GrammaireZ2Enu", 
        "typ", "synpred67_GrammaireZ2Enu", "synpred29_GrammaireZ2Enu", "synpred28_GrammaireZ2Enu", 
        "synpred62_GrammaireZ2Enu", "synpred43_GrammaireZ2Enu", "lisIngnore", 
        "synpred80_GrammaireZ2Enu", "synpred117_GrammaireZ2Enu", "act", 
        "synpred111_GrammaireZ2Enu", "fonct58", "synpred37_GrammaireZ2Enu", 
        "synpred57_GrammaireZ2Enu", "synpred88_GrammaireZ2Enu", "synpred66_GrammaireZ2Enu", 
        "synpred49_GrammaireZ2Enu", "synpred73_GrammaireZ2Enu", "fonct", 
        "synpred45_GrammaireZ2Enu", "synpred12_GrammaireZ2Enu", "synpred38_GrammaireZ2Enu", 
        "synpred21_GrammaireZ2Enu", "synpred93_GrammaireZ2Enu", "synpred91_GrammaireZ2Enu", 
        "synpred129_GrammaireZ2Enu", "synpred53_GrammaireZ2Enu", "synpred95_GrammaireZ2Enu", 
        "exps", "synpred59_GrammaireZ2Enu"
    };
     
        public int ruleLevel = 0;
        public int getRuleLevel() { return ruleLevel; }
        public void incRuleLevel() { ruleLevel++; }
        public void decRuleLevel() { ruleLevel--; }
        public GrammaireZ2EnuParser(TokenStream input) {
            this(input, DebugEventSocketProxy.DEFAULT_DEBUGGER_PORT, new RecognizerSharedState());
        }
        public GrammaireZ2EnuParser(TokenStream input, int port, RecognizerSharedState state) {
            super(input, state);
            DebugEventSocketProxy proxy =
                new DebugEventSocketProxy(this, port, null);
            setDebugListener(proxy);
            try {
                proxy.handshake();
            }
            catch (IOException ioe) {
                reportError(ioe);
            }
        }
    public GrammaireZ2EnuParser(TokenStream input, DebugEventListener dbg) {
        super(input, dbg, new RecognizerSharedState());

    }
    protected boolean evalPredicate(boolean result, String predicate) {
        dbg.semanticPredicate(result, predicate);
        return result;
    }


    public String[] getTokenNames() { return GrammaireZ2EnuParser.tokenNames; }
    public String getGrammarFileName() { return "D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g"; }


    	public Dictionary<string, object> ListProgram =  new Dictionary<string, object>();			



    // $ANTLR start "program"
    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:21:1: program : algoz ;
    public final void program() throws RecognitionException {

         	GlobalObjects.input = input;

        try { dbg.enterRule(getGrammarFileName(), "program");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(21, 1);

        try {
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:25:2: ( algoz )
            dbg.enterAlt(1);

            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:25:4: algoz
            {
            dbg.location(25,4);
            pushFollow(FOLLOW_algoz_in_program64);
            algoz();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        dbg.location(25, 9);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "program");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "program"


    // $ANTLR start "algoz"
    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:27:1: algoz : ( (st= definition )? (p= ps )? )? d= 'begin' l= lisIngnore e= 'end' ( ';' )? ( (f= fonct | a= act ) ( ';' )? )* ;
    public final void algoz() throws RecognitionException {
        Token d=null;
        Token e=null;
        GrammaireZ2EnuParser.definition_return st = null;

        List<VariableDeclare> p = null;




        try { dbg.enterRule(getGrammarFileName(), "algoz");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(27, 1);

        try {
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:30:2: ( ( (st= definition )? (p= ps )? )? d= 'begin' l= lisIngnore e= 'end' ( ';' )? ( (f= fonct | a= act ) ( ';' )? )* )
            dbg.enterAlt(1);

            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:30:4: ( (st= definition )? (p= ps )? )? d= 'begin' l= lisIngnore e= 'end' ( ';' )? ( (f= fonct | a= act ) ( ';' )? )*
            {
            dbg.location(30,4);
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:30:4: ( (st= definition )? (p= ps )? )?
            int alt3=2;
            try { dbg.enterSubRule(3);
            try { dbg.enterDecision(3);

            int LA3_0 = input.LA(1);

            if ( ((LA3_0>=ID && LA3_0<=COMMENT)||(LA3_0>=20 && LA3_0<=88)) ) {
                alt3=1;
            }
            else if ( (LA3_0==19) ) {
                int LA3_2 = input.LA(2);

                if ( (synpred3_GrammaireZ2Enu()) ) {
                    alt3=1;
                }
            }
            } finally {dbg.exitDecision(3);}

            switch (alt3) {
                case 1 :
                    dbg.enterAlt(1);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:30:5: (st= definition )? (p= ps )?
                    {
                    dbg.location(30,7);
                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:30:7: (st= definition )?
                    int alt1=2;
                    try { dbg.enterSubRule(1);
                    try { dbg.enterDecision(1);

                    int LA1_0 = input.LA(1);

                    if ( ((LA1_0>=87 && LA1_0<=88)) ) {
                        int LA1_1 = input.LA(2);

                        if ( (synpred1_GrammaireZ2Enu()) ) {
                            alt1=1;
                        }
                    }
                    } finally {dbg.exitDecision(1);}

                    switch (alt1) {
                        case 1 :
                            dbg.enterAlt(1);

                            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:0:0: st= definition
                            {
                            dbg.location(30,7);
                            pushFollow(FOLLOW_definition_in_algoz81);
                            st=definition();

                            state._fsp--;
                            if (state.failed) return ;

                            }
                            break;

                    }
                    } finally {dbg.exitSubRule(1);}

                    dbg.location(30,22);
                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:30:22: (p= ps )?
                    int alt2=2;
                    try { dbg.enterSubRule(2);
                    try { dbg.enterDecision(2);

                    int LA2_0 = input.LA(1);

                    if ( ((LA2_0>=ID && LA2_0<=COMMENT)||(LA2_0>=20 && LA2_0<=88)) ) {
                        alt2=1;
                    }
                    } finally {dbg.exitDecision(2);}

                    switch (alt2) {
                        case 1 :
                            dbg.enterAlt(1);

                            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:0:0: p= ps
                            {
                            dbg.location(30,22);
                            pushFollow(FOLLOW_ps_in_algoz87);
                            p=ps();

                            state._fsp--;
                            if (state.failed) return ;

                            }
                            break;

                    }
                    } finally {dbg.exitSubRule(2);}


                    }
                    break;

            }
            } finally {dbg.exitSubRule(3);}

            dbg.location(30,33);
            d=(Token)match(input,19,FOLLOW_19_in_algoz97); if (state.failed) return ;
            dbg.location(30,43);
            pushFollow(FOLLOW_lisIngnore_in_algoz101);
            lisIngnore();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(30,56);
            e=(Token)match(input,20,FOLLOW_20_in_algoz105); if (state.failed) return ;
            dbg.location(31,2);
            if ( state.backtracking==0 ) {
              	
              	 BaseProgramme baseProgramme;	 
              	 List<VariableDeclare> l = new List<VariableDeclare>();
              	 if(p != null) l = p;
              	 if(st != null) baseProgramme = new BaseProgramme((st!=null?((Token)st.start):null), e, d, l);
              	 baseProgramme = new BaseProgramme(new Point(0,0), e, d, l);
              	 try{
              	 	ListProgram.Add("$", baseProgramme);
              	 }catch (ArgumentException ae){
              	 }
              	
            }
            dbg.location(42,3);
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:42:3: ( ';' )?
            int alt4=2;
            try { dbg.enterSubRule(4);
            try { dbg.enterDecision(4);

            int LA4_0 = input.LA(1);

            if ( (LA4_0==21) ) {
                alt4=1;
            }
            } finally {dbg.exitDecision(4);}

            switch (alt4) {
                case 1 :
                    dbg.enterAlt(1);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:42:4: ';'
                    {
                    dbg.location(42,4);
                    match(input,21,FOLLOW_21_in_algoz114); if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(4);}

            dbg.location(42,10);
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:42:10: ( (f= fonct | a= act ) ( ';' )? )*
            try { dbg.enterSubRule(7);

            loop7:
            do {
                int alt7=2;
                try { dbg.enterDecision(7);

                int LA7_0 = input.LA(1);

                if ( (LA7_0==22||LA7_0==25) ) {
                    alt7=1;
                }


                } finally {dbg.exitDecision(7);}

                switch (alt7) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:42:12: (f= fonct | a= act ) ( ';' )?
            	    {
            	    dbg.location(42,12);
            	    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:42:12: (f= fonct | a= act )
            	    int alt5=2;
            	    try { dbg.enterSubRule(5);
            	    try { dbg.enterDecision(5);

            	    int LA5_0 = input.LA(1);

            	    if ( (LA5_0==25) ) {
            	        alt5=1;
            	    }
            	    else if ( (LA5_0==22) ) {
            	        alt5=2;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return ;}
            	        NoViableAltException nvae =
            	            new NoViableAltException("", 5, 0, input);

            	        dbg.recognitionException(nvae);
            	        throw nvae;
            	    }
            	    } finally {dbg.exitDecision(5);}

            	    switch (alt5) {
            	        case 1 :
            	            dbg.enterAlt(1);

            	            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:42:14: f= fonct
            	            {
            	            dbg.location(42,15);
            	            pushFollow(FOLLOW_fonct_in_algoz124);
            	            fonct();

            	            state._fsp--;
            	            if (state.failed) return ;

            	            }
            	            break;
            	        case 2 :
            	            dbg.enterAlt(2);

            	            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:42:25: a= act
            	            {
            	            dbg.location(42,26);
            	            pushFollow(FOLLOW_act_in_algoz131);
            	            act();

            	            state._fsp--;
            	            if (state.failed) return ;

            	            }
            	            break;

            	    }
            	    } finally {dbg.exitSubRule(5);}

            	    dbg.location(42,32);
            	    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:42:32: ( ';' )?
            	    int alt6=2;
            	    try { dbg.enterSubRule(6);
            	    try { dbg.enterDecision(6);

            	    int LA6_0 = input.LA(1);

            	    if ( (LA6_0==21) ) {
            	        alt6=1;
            	    }
            	    } finally {dbg.exitDecision(6);}

            	    switch (alt6) {
            	        case 1 :
            	            dbg.enterAlt(1);

            	            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:42:33: ';'
            	            {
            	            dbg.location(42,33);
            	            match(input,21,FOLLOW_21_in_algoz135); if (state.failed) return ;

            	            }
            	            break;

            	    }
            	    } finally {dbg.exitSubRule(6);}


            	    }
            	    break;

            	default :
            	    break loop7;
                }
            } while (true);
            } finally {dbg.exitSubRule(7);}


            }

        }
        catch (Exception ex) {
        }
        finally {
        }
        dbg.location(43, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "algoz");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "algoz"


    // $ANTLR start "act"
    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:46:1: act : a= 'action' (id= ID )? ( '(' (i= li )? ')' )? ( ';' )? ( ( definition )? (p= ps )? )? d= 'begin' l= lisIngnore e= 'end' ;
    public final void act() throws RecognitionException {
        Token a=null;
        Token id=null;
        Token d=null;
        Token e=null;
        List<VariableDeclare> i = null;

        List<VariableDeclare> p = null;


        try { dbg.enterRule(getGrammarFileName(), "act");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(46, 1);

        try {
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:47:2: (a= 'action' (id= ID )? ( '(' (i= li )? ')' )? ( ';' )? ( ( definition )? (p= ps )? )? d= 'begin' l= lisIngnore e= 'end' )
            dbg.enterAlt(1);

            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:47:4: a= 'action' (id= ID )? ( '(' (i= li )? ')' )? ( ';' )? ( ( definition )? (p= ps )? )? d= 'begin' l= lisIngnore e= 'end'
            {
            dbg.location(47,5);
            a=(Token)match(input,22,FOLLOW_22_in_act166); if (state.failed) return ;
            dbg.location(47,17);
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:47:17: (id= ID )?
            int alt8=2;
            try { dbg.enterSubRule(8);
            try { dbg.enterDecision(8);

            int LA8_0 = input.LA(1);

            if ( (LA8_0==ID) ) {
                int LA8_1 = input.LA(2);

                if ( (synpred8_GrammaireZ2Enu()) ) {
                    alt8=1;
                }
            }
            } finally {dbg.exitDecision(8);}

            switch (alt8) {
                case 1 :
                    dbg.enterAlt(1);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:0:0: id= ID
                    {
                    dbg.location(47,17);
                    id=(Token)match(input,ID,FOLLOW_ID_in_act170); if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(8);}

            dbg.location(47,23);
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:47:23: ( '(' (i= li )? ')' )?
            int alt10=2;
            try { dbg.enterSubRule(10);
            try { dbg.enterDecision(10);

            try {
                isCyclicDecision = true;
                alt10 = dfa10.predict(input);
            }
            catch (NoViableAltException nvae) {
                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(10);}

            switch (alt10) {
                case 1 :
                    dbg.enterAlt(1);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:47:25: '(' (i= li )? ')'
                    {
                    dbg.location(47,25);
                    match(input,23,FOLLOW_23_in_act176); if (state.failed) return ;
                    dbg.location(47,30);
                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:47:30: (i= li )?
                    int alt9=2;
                    try { dbg.enterSubRule(9);
                    try { dbg.enterDecision(9);

                    int LA9_0 = input.LA(1);

                    if ( (LA9_0==ID) ) {
                        alt9=1;
                    }
                    } finally {dbg.exitDecision(9);}

                    switch (alt9) {
                        case 1 :
                            dbg.enterAlt(1);

                            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:0:0: i= li
                            {
                            dbg.location(47,30);
                            pushFollow(FOLLOW_li_in_act180);
                            i=li();

                            state._fsp--;
                            if (state.failed) return ;

                            }
                            break;

                    }
                    } finally {dbg.exitSubRule(9);}

                    dbg.location(47,35);
                    match(input,24,FOLLOW_24_in_act183); if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(10);}

            dbg.location(47,42);
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:47:42: ( ';' )?
            int alt11=2;
            try { dbg.enterSubRule(11);
            try { dbg.enterDecision(11);

            int LA11_0 = input.LA(1);

            if ( (LA11_0==21) ) {
                int LA11_1 = input.LA(2);

                if ( (synpred11_GrammaireZ2Enu()) ) {
                    alt11=1;
                }
            }
            } finally {dbg.exitDecision(11);}

            switch (alt11) {
                case 1 :
                    dbg.enterAlt(1);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:47:43: ';'
                    {
                    dbg.location(47,43);
                    match(input,21,FOLLOW_21_in_act189); if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(11);}

            dbg.location(47,49);
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:47:49: ( ( definition )? (p= ps )? )?
            int alt14=2;
            try { dbg.enterSubRule(14);
            try { dbg.enterDecision(14);

            int LA14_0 = input.LA(1);

            if ( ((LA14_0>=ID && LA14_0<=COMMENT)||(LA14_0>=20 && LA14_0<=88)) ) {
                alt14=1;
            }
            else if ( (LA14_0==19) ) {
                int LA14_2 = input.LA(2);

                if ( (synpred14_GrammaireZ2Enu()) ) {
                    alt14=1;
                }
            }
            } finally {dbg.exitDecision(14);}

            switch (alt14) {
                case 1 :
                    dbg.enterAlt(1);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:47:50: ( definition )? (p= ps )?
                    {
                    dbg.location(47,50);
                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:47:50: ( definition )?
                    int alt12=2;
                    try { dbg.enterSubRule(12);
                    try { dbg.enterDecision(12);

                    int LA12_0 = input.LA(1);

                    if ( ((LA12_0>=87 && LA12_0<=88)) ) {
                        int LA12_1 = input.LA(2);

                        if ( (synpred12_GrammaireZ2Enu()) ) {
                            alt12=1;
                        }
                    }
                    } finally {dbg.exitDecision(12);}

                    switch (alt12) {
                        case 1 :
                            dbg.enterAlt(1);

                            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:0:0: definition
                            {
                            dbg.location(47,50);
                            pushFollow(FOLLOW_definition_in_act194);
                            definition();

                            state._fsp--;
                            if (state.failed) return ;

                            }
                            break;

                    }
                    } finally {dbg.exitSubRule(12);}

                    dbg.location(47,63);
                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:47:63: (p= ps )?
                    int alt13=2;
                    try { dbg.enterSubRule(13);
                    try { dbg.enterDecision(13);

                    int LA13_0 = input.LA(1);

                    if ( ((LA13_0>=ID && LA13_0<=COMMENT)||(LA13_0>=20 && LA13_0<=88)) ) {
                        alt13=1;
                    }
                    } finally {dbg.exitDecision(13);}

                    switch (alt13) {
                        case 1 :
                            dbg.enterAlt(1);

                            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:0:0: p= ps
                            {
                            dbg.location(47,63);
                            pushFollow(FOLLOW_ps_in_act199);
                            p=ps();

                            state._fsp--;
                            if (state.failed) return ;

                            }
                            break;

                    }
                    } finally {dbg.exitSubRule(13);}


                    }
                    break;

            }
            } finally {dbg.exitSubRule(14);}

            dbg.location(47,72);
            d=(Token)match(input,19,FOLLOW_19_in_act207); if (state.failed) return ;
            dbg.location(47,82);
            pushFollow(FOLLOW_lisIngnore_in_act211);
            lisIngnore();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(47,95);
            e=(Token)match(input,20,FOLLOW_20_in_act215); if (state.failed) return ;
            dbg.location(48,2);
            if ( state.backtracking==0 ) {
               
              	 ActionToken actionToken;
              	 IToken t = d;  
              	 if(a != null) t = a;
              	 if(id == null) id = a;
              	 List<VariableDeclare> l = new List<VariableDeclare>();
              	 if(p != null) l = p;	 
              	 actionToken = new ActionToken(t, e, id, d, l, i);
              	 try{
              	 	ListProgram.Add((id!=null?id.getText():null), actionToken);
              	 }catch (ArgumentException ae){
              	 }
              	
            }

            }

        }
        catch (Exception ex) {
        }
        finally {
        }
        dbg.location(61, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "act");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "act"


    // $ANTLR start "fonct"
    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:64:1: fonct : f= 'function' (id= ID )? '(' (i= li )? ')' ':' (ta= typ )? ( ( definition )? (p= ps )? )? d= 'begin' l= lisIngnore e= 'end' ;
    public final void fonct() throws RecognitionException {
        Token f=null;
        Token id=null;
        Token d=null;
        Token e=null;
        List<VariableDeclare> i = null;

        GrammaireZ2EnuParser.typ_return ta = null;

        List<VariableDeclare> p = null;


        try { dbg.enterRule(getGrammarFileName(), "fonct");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(64, 1);

        try {
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:65:2: (f= 'function' (id= ID )? '(' (i= li )? ')' ':' (ta= typ )? ( ( definition )? (p= ps )? )? d= 'begin' l= lisIngnore e= 'end' )
            dbg.enterAlt(1);

            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:65:4: f= 'function' (id= ID )? '(' (i= li )? ')' ':' (ta= typ )? ( ( definition )? (p= ps )? )? d= 'begin' l= lisIngnore e= 'end'
            {
            dbg.location(65,5);
            f=(Token)match(input,25,FOLLOW_25_in_fonct242); if (state.failed) return ;
            dbg.location(65,19);
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:65:19: (id= ID )?
            int alt15=2;
            try { dbg.enterSubRule(15);
            try { dbg.enterDecision(15);

            int LA15_0 = input.LA(1);

            if ( (LA15_0==ID) ) {
                alt15=1;
            }
            } finally {dbg.exitDecision(15);}

            switch (alt15) {
                case 1 :
                    dbg.enterAlt(1);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:0:0: id= ID
                    {
                    dbg.location(65,19);
                    id=(Token)match(input,ID,FOLLOW_ID_in_fonct246); if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(15);}

            dbg.location(65,24);
            match(input,23,FOLLOW_23_in_fonct249); if (state.failed) return ;
            dbg.location(65,29);
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:65:29: (i= li )?
            int alt16=2;
            try { dbg.enterSubRule(16);
            try { dbg.enterDecision(16);

            int LA16_0 = input.LA(1);

            if ( (LA16_0==ID) ) {
                alt16=1;
            }
            } finally {dbg.exitDecision(16);}

            switch (alt16) {
                case 1 :
                    dbg.enterAlt(1);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:0:0: i= li
                    {
                    dbg.location(65,29);
                    pushFollow(FOLLOW_li_in_fonct253);
                    i=li();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(16);}

            dbg.location(65,34);
            match(input,24,FOLLOW_24_in_fonct256); if (state.failed) return ;
            dbg.location(65,38);
            match(input,26,FOLLOW_26_in_fonct258); if (state.failed) return ;
            dbg.location(65,44);
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:65:44: (ta= typ )?
            int alt17=2;
            try { dbg.enterSubRule(17);
            try { dbg.enterDecision(17);

            try {
                isCyclicDecision = true;
                alt17 = dfa17.predict(input);
            }
            catch (NoViableAltException nvae) {
                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(17);}

            switch (alt17) {
                case 1 :
                    dbg.enterAlt(1);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:0:0: ta= typ
                    {
                    dbg.location(65,44);
                    pushFollow(FOLLOW_typ_in_fonct262);
                    ta=typ();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(17);}

            dbg.location(65,50);
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:65:50: ( ( definition )? (p= ps )? )?
            int alt20=2;
            try { dbg.enterSubRule(20);
            try { dbg.enterDecision(20);

            int LA20_0 = input.LA(1);

            if ( ((LA20_0>=ID && LA20_0<=COMMENT)||(LA20_0>=20 && LA20_0<=88)) ) {
                alt20=1;
            }
            else if ( (LA20_0==19) ) {
                int LA20_2 = input.LA(2);

                if ( (synpred20_GrammaireZ2Enu()) ) {
                    alt20=1;
                }
            }
            } finally {dbg.exitDecision(20);}

            switch (alt20) {
                case 1 :
                    dbg.enterAlt(1);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:65:52: ( definition )? (p= ps )?
                    {
                    dbg.location(65,52);
                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:65:52: ( definition )?
                    int alt18=2;
                    try { dbg.enterSubRule(18);
                    try { dbg.enterDecision(18);

                    int LA18_0 = input.LA(1);

                    if ( ((LA18_0>=87 && LA18_0<=88)) ) {
                        int LA18_1 = input.LA(2);

                        if ( (synpred18_GrammaireZ2Enu()) ) {
                            alt18=1;
                        }
                    }
                    } finally {dbg.exitDecision(18);}

                    switch (alt18) {
                        case 1 :
                            dbg.enterAlt(1);

                            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:0:0: definition
                            {
                            dbg.location(65,52);
                            pushFollow(FOLLOW_definition_in_fonct267);
                            definition();

                            state._fsp--;
                            if (state.failed) return ;

                            }
                            break;

                    }
                    } finally {dbg.exitSubRule(18);}

                    dbg.location(65,65);
                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:65:65: (p= ps )?
                    int alt19=2;
                    try { dbg.enterSubRule(19);
                    try { dbg.enterDecision(19);

                    int LA19_0 = input.LA(1);

                    if ( ((LA19_0>=ID && LA19_0<=COMMENT)||(LA19_0>=20 && LA19_0<=88)) ) {
                        alt19=1;
                    }
                    } finally {dbg.exitDecision(19);}

                    switch (alt19) {
                        case 1 :
                            dbg.enterAlt(1);

                            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:0:0: p= ps
                            {
                            dbg.location(65,65);
                            pushFollow(FOLLOW_ps_in_fonct272);
                            p=ps();

                            state._fsp--;
                            if (state.failed) return ;

                            }
                            break;

                    }
                    } finally {dbg.exitSubRule(19);}


                    }
                    break;

            }
            } finally {dbg.exitSubRule(20);}

            dbg.location(65,74);
            d=(Token)match(input,19,FOLLOW_19_in_fonct280); if (state.failed) return ;
            dbg.location(65,84);
            pushFollow(FOLLOW_lisIngnore_in_fonct284);
            lisIngnore();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(65,97);
            e=(Token)match(input,20,FOLLOW_20_in_fonct288); if (state.failed) return ;
            dbg.location(66,2);
            if ( state.backtracking==0 ) {

              	 FonctionToken fonctionToken;
              	 IToken t = d;  
              	 if(f != null) t = f;
              	 if(id == null) id = f;
              	 List<VariableDeclare> l = new List<VariableDeclare>();
              	 if(p != null) l = p;	 
              	 fonctionToken = new FonctionToken(t, e, id, (ta!=null?input.toString(ta.start,ta.stop):null), d, l,i);
              	 try{
              	 	ListProgram.Add((id!=null?id.getText():null), fonctionToken);
              	 }catch (ArgumentException ae){
              	 }	 
              	
            }

            }

        }
        catch (Exception ex) {
        }
        finally {
        }
        dbg.location(79, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "fonct");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "fonct"


    // $ANTLR start "ps"
    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:82:1: ps returns [List<VariableDeclare> Vars = new List<VariableDeclare>()] : (s1= s ';' ) ( ( definition )? s2= s ';' )* ;
    public final List<VariableDeclare> ps() throws RecognitionException {
        List<VariableDeclare> Vars =  new List<VariableDeclare>();

        GrammaireZ2EnuParser.s_return s1 = null;

        GrammaireZ2EnuParser.s_return s2 = null;


        try { dbg.enterRule(getGrammarFileName(), "ps");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(82, 1);

        try {
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:83:2: ( (s1= s ';' ) ( ( definition )? s2= s ';' )* )
            dbg.enterAlt(1);

            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:83:4: (s1= s ';' ) ( ( definition )? s2= s ';' )*
            {
            dbg.location(83,4);
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:83:4: (s1= s ';' )
            dbg.enterAlt(1);

            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:83:5: s1= s ';'
            {
            dbg.location(83,8);
            pushFollow(FOLLOW_s_in_ps327);
            s1=s();

            state._fsp--;
            if (state.failed) return Vars;
            dbg.location(83,44);
            if ( state.backtracking==0 ) {
              Vars.AddRange((s1!=null?s1.ids:null));
            }
            dbg.location(83,71);
            match(input,21,FOLLOW_21_in_ps363); if (state.failed) return Vars;

            }

            dbg.location(84,4);
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:84:4: ( ( definition )? s2= s ';' )*
            try { dbg.enterSubRule(22);

            loop22:
            do {
                int alt22=2;
                try { dbg.enterDecision(22);

                int LA22_0 = input.LA(1);

                if ( ((LA22_0>=ID && LA22_0<=COMMENT)||(LA22_0>=20 && LA22_0<=88)) ) {
                    alt22=1;
                }


                } finally {dbg.exitDecision(22);}

                switch (alt22) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:84:5: ( definition )? s2= s ';'
            	    {
            	    dbg.location(84,5);
            	    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:84:5: ( definition )?
            	    int alt21=2;
            	    try { dbg.enterSubRule(21);
            	    try { dbg.enterDecision(21);

            	    int LA21_0 = input.LA(1);

            	    if ( ((LA21_0>=87 && LA21_0<=88)) ) {
            	        int LA21_1 = input.LA(2);

            	        if ( (synpred21_GrammaireZ2Enu()) ) {
            	            alt21=1;
            	        }
            	    }
            	    } finally {dbg.exitDecision(21);}

            	    switch (alt21) {
            	        case 1 :
            	            dbg.enterAlt(1);

            	            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:0:0: definition
            	            {
            	            dbg.location(84,5);
            	            pushFollow(FOLLOW_definition_in_ps371);
            	            definition();

            	            state._fsp--;
            	            if (state.failed) return Vars;

            	            }
            	            break;

            	    }
            	    } finally {dbg.exitSubRule(21);}

            	    dbg.location(84,20);
            	    pushFollow(FOLLOW_s_in_ps378);
            	    s2=s();

            	    state._fsp--;
            	    if (state.failed) return Vars;
            	    dbg.location(84,44);
            	    if ( state.backtracking==0 ) {
            	      Vars.AddRange((s2!=null?s2.ids:null));
            	    }
            	    dbg.location(84,71);
            	    match(input,21,FOLLOW_21_in_ps402); if (state.failed) return Vars;

            	    }
            	    break;

            	default :
            	    break loop22;
                }
            } while (true);
            } finally {dbg.exitSubRule(22);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        dbg.location(85, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "ps");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return Vars;
    }
    // $ANTLR end "ps"

    public static class s_return extends ParserRuleReturnScope {
        public List<VariableDeclare> ids=new List<VariableDeclare>();
        public string type;
    };

    // $ANTLR start "s"
    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:87:1: s returns [List<VariableDeclare> ids=new List<VariableDeclare>(), string type] : ( ( li ( Sep ) (t1= typ | (a1= 'action' | f1= 'function' '(' t2= typ ')' ) ) ) | lisIngnorebeing );
    public final GrammaireZ2EnuParser.s_return s() throws RecognitionException {
        GrammaireZ2EnuParser.s_return retval = new GrammaireZ2EnuParser.s_return();
        retval.start = input.LT(1);

        Token a1=null;
        Token f1=null;
        GrammaireZ2EnuParser.typ_return t1 = null;

        GrammaireZ2EnuParser.typ_return t2 = null;

        List<VariableDeclare> li1 = null;


        try { dbg.enterRule(getGrammarFileName(), "s");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(87, 1);

        try {
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:88:2: ( ( li ( Sep ) (t1= typ | (a1= 'action' | f1= 'function' '(' t2= typ ')' ) ) ) | lisIngnorebeing )
            int alt25=2;
            try { dbg.enterDecision(25);

            try {
                isCyclicDecision = true;
                alt25 = dfa25.predict(input);
            }
            catch (NoViableAltException nvae) {
                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(25);}

            switch (alt25) {
                case 1 :
                    dbg.enterAlt(1);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:88:4: ( li ( Sep ) (t1= typ | (a1= 'action' | f1= 'function' '(' t2= typ ')' ) ) )
                    {
                    dbg.location(88,4);
                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:88:4: ( li ( Sep ) (t1= typ | (a1= 'action' | f1= 'function' '(' t2= typ ')' ) ) )
                    dbg.enterAlt(1);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:88:5: li ( Sep ) (t1= typ | (a1= 'action' | f1= 'function' '(' t2= typ ')' ) )
                    {
                    dbg.location(88,5);
                    pushFollow(FOLLOW_li_in_s423);
                    li1=li();

                    state._fsp--;
                    if (state.failed) return retval;
                    dbg.location(88,8);
                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:88:8: ( Sep )
                    dbg.enterAlt(1);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:88:9: Sep
                    {
                    dbg.location(88,9);
                    match(input,Sep,FOLLOW_Sep_in_s426); if (state.failed) return retval;

                    }

                    dbg.location(88,14);
                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:88:14: (t1= typ | (a1= 'action' | f1= 'function' '(' t2= typ ')' ) )
                    int alt24=2;
                    try { dbg.enterSubRule(24);
                    try { dbg.enterDecision(24);

                    int LA24_0 = input.LA(1);

                    if ( (LA24_0==Types||LA24_0==Autres||LA24_0==23||LA24_0==28||(LA24_0>=31 && LA24_0<=32)||(LA24_0>=36 && LA24_0<=37)) ) {
                        alt24=1;
                    }
                    else if ( (LA24_0==22||LA24_0==25) ) {
                        alt24=2;
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return retval;}
                        NoViableAltException nvae =
                            new NoViableAltException("", 24, 0, input);

                        dbg.recognitionException(nvae);
                        throw nvae;
                    }
                    } finally {dbg.exitDecision(24);}

                    switch (alt24) {
                        case 1 :
                            dbg.enterAlt(1);

                            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:88:15: t1= typ
                            {
                            dbg.location(88,18);
                            pushFollow(FOLLOW_typ_in_s434);
                            t1=typ();

                            state._fsp--;
                            if (state.failed) return retval;

                            }
                            break;
                        case 2 :
                            dbg.enterAlt(2);

                            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:88:26: (a1= 'action' | f1= 'function' '(' t2= typ ')' )
                            {
                            dbg.location(88,26);
                            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:88:26: (a1= 'action' | f1= 'function' '(' t2= typ ')' )
                            int alt23=2;
                            try { dbg.enterSubRule(23);
                            try { dbg.enterDecision(23);

                            int LA23_0 = input.LA(1);

                            if ( (LA23_0==22) ) {
                                alt23=1;
                            }
                            else if ( (LA23_0==25) ) {
                                alt23=2;
                            }
                            else {
                                if (state.backtracking>0) {state.failed=true; return retval;}
                                NoViableAltException nvae =
                                    new NoViableAltException("", 23, 0, input);

                                dbg.recognitionException(nvae);
                                throw nvae;
                            }
                            } finally {dbg.exitDecision(23);}

                            switch (alt23) {
                                case 1 :
                                    dbg.enterAlt(1);

                                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:88:27: a1= 'action'
                                    {
                                    dbg.location(88,30);
                                    a1=(Token)match(input,22,FOLLOW_22_in_s443); if (state.failed) return retval;

                                    }
                                    break;
                                case 2 :
                                    dbg.enterAlt(2);

                                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:88:41: f1= 'function' '(' t2= typ ')'
                                    {
                                    dbg.location(88,44);
                                    f1=(Token)match(input,25,FOLLOW_25_in_s449); if (state.failed) return retval;
                                    dbg.location(88,57);
                                    match(input,23,FOLLOW_23_in_s451); if (state.failed) return retval;
                                    dbg.location(88,64);
                                    pushFollow(FOLLOW_typ_in_s457);
                                    t2=typ();

                                    state._fsp--;
                                    if (state.failed) return retval;
                                    dbg.location(88,70);
                                    match(input,24,FOLLOW_24_in_s459); if (state.failed) return retval;

                                    }
                                    break;

                            }
                            } finally {dbg.exitSubRule(23);}


                            }
                            break;

                    }
                    } finally {dbg.exitSubRule(24);}

                    dbg.location(89,4);
                    if ( state.backtracking==0 ) {

                      	   retval.ids = li1; 
                      	   string ty = (t1!=null?input.toString(t1.start,t1.stop):null)+(a1!=null?a1.getText():null)+(f1!=null?f1.getText():null)+(t2!=null?"("+(t2!=null?input.toString(t2.start,t2.stop):null)+")":null);
                      	   foreach(VariableDeclare vd in li1)
                      	   vd.Type = ty;
                      	   retval.type = ty;
                      	  
                    }

                    }


                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:96:5: lisIngnorebeing
                    {
                    dbg.location(96,5);
                    pushFollow(FOLLOW_lisIngnorebeing_in_s475);
                    lisIngnorebeing();

                    state._fsp--;
                    if (state.failed) return retval;

                    }
                    break;

            }
            retval.stop = input.LT(-1);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        dbg.location(97, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "s");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "s"

    public static class typ_return extends ParserRuleReturnScope {
    };

    // $ANTLR start "typ"
    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:100:1: typ : ( Types | ( structsimple | strucrcomplexe ) ( 'dynamic' )? | ( 'pointer' 'to' )? typecomp ( 'of' typecomp )* 'of' ( structsimple ( 'dynamic' )? | Types ) | 'file' 'of' ( Types | 'vector' ( CSTE ) 'of' Types | structsimple | strucrcomplexe ) ( 'header' )? '(' Types ( ',' Types )* ')' 'buffer' li );
    public final GrammaireZ2EnuParser.typ_return typ() throws RecognitionException {
        GrammaireZ2EnuParser.typ_return retval = new GrammaireZ2EnuParser.typ_return();
        retval.start = input.LT(1);

        try { dbg.enterRule(getGrammarFileName(), "typ");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(100, 1);

        try {
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:101:3: ( Types | ( structsimple | strucrcomplexe ) ( 'dynamic' )? | ( 'pointer' 'to' )? typecomp ( 'of' typecomp )* 'of' ( structsimple ( 'dynamic' )? | Types ) | 'file' 'of' ( Types | 'vector' ( CSTE ) 'of' Types | structsimple | strucrcomplexe ) ( 'header' )? '(' Types ( ',' Types )* ')' 'buffer' li )
            int alt35=4;
            try { dbg.enterDecision(35);

            switch ( input.LA(1) ) {
            case Types:
                {
                alt35=1;
                }
                break;
            case 23:
            case 36:
                {
                alt35=2;
                }
                break;
            case Autres:
            case 28:
            case 32:
            case 37:
                {
                alt35=3;
                }
                break;
            case 31:
                {
                alt35=4;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 35, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }

            } finally {dbg.exitDecision(35);}

            switch (alt35) {
                case 1 :
                    dbg.enterAlt(1);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:101:5: Types
                    {
                    dbg.location(101,5);
                    match(input,Types,FOLLOW_Types_in_typ492); if (state.failed) return retval;

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:102:4: ( structsimple | strucrcomplexe ) ( 'dynamic' )?
                    {
                    dbg.location(102,4);
                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:102:4: ( structsimple | strucrcomplexe )
                    int alt26=2;
                    try { dbg.enterSubRule(26);
                    try { dbg.enterDecision(26);

                    try {
                        isCyclicDecision = true;
                        alt26 = dfa26.predict(input);
                    }
                    catch (NoViableAltException nvae) {
                        dbg.recognitionException(nvae);
                        throw nvae;
                    }
                    } finally {dbg.exitDecision(26);}

                    switch (alt26) {
                        case 1 :
                            dbg.enterAlt(1);

                            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:102:6: structsimple
                            {
                            dbg.location(102,6);
                            pushFollow(FOLLOW_structsimple_in_typ501);
                            structsimple();

                            state._fsp--;
                            if (state.failed) return retval;

                            }
                            break;
                        case 2 :
                            dbg.enterAlt(2);

                            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:102:21: strucrcomplexe
                            {
                            dbg.location(102,21);
                            pushFollow(FOLLOW_strucrcomplexe_in_typ505);
                            strucrcomplexe();

                            state._fsp--;
                            if (state.failed) return retval;

                            }
                            break;

                    }
                    } finally {dbg.exitSubRule(26);}

                    dbg.location(102,38);
                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:102:38: ( 'dynamic' )?
                    int alt27=2;
                    try { dbg.enterSubRule(27);
                    try { dbg.enterDecision(27);

                    int LA27_0 = input.LA(1);

                    if ( (LA27_0==27) ) {
                        int LA27_1 = input.LA(2);

                        if ( (synpred28_GrammaireZ2Enu()) ) {
                            alt27=1;
                        }
                    }
                    } finally {dbg.exitDecision(27);}

                    switch (alt27) {
                        case 1 :
                            dbg.enterAlt(1);

                            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:0:0: 'dynamic'
                            {
                            dbg.location(102,38);
                            match(input,27,FOLLOW_27_in_typ509); if (state.failed) return retval;

                            }
                            break;

                    }
                    } finally {dbg.exitSubRule(27);}


                    }
                    break;
                case 3 :
                    dbg.enterAlt(3);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:103:4: ( 'pointer' 'to' )? typecomp ( 'of' typecomp )* 'of' ( structsimple ( 'dynamic' )? | Types )
                    {
                    dbg.location(103,4);
                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:103:4: ( 'pointer' 'to' )?
                    int alt28=2;
                    try { dbg.enterSubRule(28);
                    try { dbg.enterDecision(28);

                    int LA28_0 = input.LA(1);

                    if ( (LA28_0==28) ) {
                        alt28=1;
                    }
                    } finally {dbg.exitDecision(28);}

                    switch (alt28) {
                        case 1 :
                            dbg.enterAlt(1);

                            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:103:5: 'pointer' 'to'
                            {
                            dbg.location(103,5);
                            match(input,28,FOLLOW_28_in_typ518); if (state.failed) return retval;
                            dbg.location(103,15);
                            match(input,29,FOLLOW_29_in_typ520); if (state.failed) return retval;

                            }
                            break;

                    }
                    } finally {dbg.exitSubRule(28);}

                    dbg.location(103,23);
                    pushFollow(FOLLOW_typecomp_in_typ525);
                    typecomp();

                    state._fsp--;
                    if (state.failed) return retval;
                    dbg.location(103,32);
                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:103:32: ( 'of' typecomp )*
                    try { dbg.enterSubRule(29);

                    loop29:
                    do {
                        int alt29=2;
                        try { dbg.enterDecision(29);

                        int LA29_0 = input.LA(1);

                        if ( (LA29_0==30) ) {
                            int LA29_1 = input.LA(2);

                            if ( (LA29_1==Autres||LA29_1==32||LA29_1==37) ) {
                                alt29=1;
                            }


                        }


                        } finally {dbg.exitDecision(29);}

                        switch (alt29) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:103:33: 'of' typecomp
                    	    {
                    	    dbg.location(103,33);
                    	    match(input,30,FOLLOW_30_in_typ528); if (state.failed) return retval;
                    	    dbg.location(103,38);
                    	    pushFollow(FOLLOW_typecomp_in_typ530);
                    	    typecomp();

                    	    state._fsp--;
                    	    if (state.failed) return retval;

                    	    }
                    	    break;

                    	default :
                    	    break loop29;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(29);}

                    dbg.location(103,50);
                    match(input,30,FOLLOW_30_in_typ535); if (state.failed) return retval;
                    dbg.location(103,55);
                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:103:55: ( structsimple ( 'dynamic' )? | Types )
                    int alt31=2;
                    try { dbg.enterSubRule(31);
                    try { dbg.enterDecision(31);

                    int LA31_0 = input.LA(1);

                    if ( (LA31_0==23||LA31_0==36) ) {
                        alt31=1;
                    }
                    else if ( (LA31_0==Types) ) {
                        alt31=2;
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return retval;}
                        NoViableAltException nvae =
                            new NoViableAltException("", 31, 0, input);

                        dbg.recognitionException(nvae);
                        throw nvae;
                    }
                    } finally {dbg.exitDecision(31);}

                    switch (alt31) {
                        case 1 :
                            dbg.enterAlt(1);

                            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:103:57: structsimple ( 'dynamic' )?
                            {
                            dbg.location(103,57);
                            pushFollow(FOLLOW_structsimple_in_typ539);
                            structsimple();

                            state._fsp--;
                            if (state.failed) return retval;
                            dbg.location(103,70);
                            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:103:70: ( 'dynamic' )?
                            int alt30=2;
                            try { dbg.enterSubRule(30);
                            try { dbg.enterDecision(30);

                            int LA30_0 = input.LA(1);

                            if ( (LA30_0==27) ) {
                                int LA30_1 = input.LA(2);

                                if ( (synpred32_GrammaireZ2Enu()) ) {
                                    alt30=1;
                                }
                            }
                            } finally {dbg.exitDecision(30);}

                            switch (alt30) {
                                case 1 :
                                    dbg.enterAlt(1);

                                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:0:0: 'dynamic'
                                    {
                                    dbg.location(103,70);
                                    match(input,27,FOLLOW_27_in_typ541); if (state.failed) return retval;

                                    }
                                    break;

                            }
                            } finally {dbg.exitSubRule(30);}


                            }
                            break;
                        case 2 :
                            dbg.enterAlt(2);

                            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:103:83: Types
                            {
                            dbg.location(103,83);
                            match(input,Types,FOLLOW_Types_in_typ546); if (state.failed) return retval;

                            }
                            break;

                    }
                    } finally {dbg.exitSubRule(31);}


                    }
                    break;
                case 4 :
                    dbg.enterAlt(4);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:104:4: 'file' 'of' ( Types | 'vector' ( CSTE ) 'of' Types | structsimple | strucrcomplexe ) ( 'header' )? '(' Types ( ',' Types )* ')' 'buffer' li
                    {
                    dbg.location(104,4);
                    match(input,31,FOLLOW_31_in_typ555); if (state.failed) return retval;
                    dbg.location(104,11);
                    match(input,30,FOLLOW_30_in_typ557); if (state.failed) return retval;
                    dbg.location(104,16);
                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:104:16: ( Types | 'vector' ( CSTE ) 'of' Types | structsimple | strucrcomplexe )
                    int alt32=4;
                    try { dbg.enterSubRule(32);
                    try { dbg.enterDecision(32);

                    try {
                        isCyclicDecision = true;
                        alt32 = dfa32.predict(input);
                    }
                    catch (NoViableAltException nvae) {
                        dbg.recognitionException(nvae);
                        throw nvae;
                    }
                    } finally {dbg.exitDecision(32);}

                    switch (alt32) {
                        case 1 :
                            dbg.enterAlt(1);

                            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:104:18: Types
                            {
                            dbg.location(104,18);
                            match(input,Types,FOLLOW_Types_in_typ561); if (state.failed) return retval;

                            }
                            break;
                        case 2 :
                            dbg.enterAlt(2);

                            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:104:26: 'vector' ( CSTE ) 'of' Types
                            {
                            dbg.location(104,26);
                            match(input,32,FOLLOW_32_in_typ565); if (state.failed) return retval;
                            dbg.location(104,34);
                            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:104:34: ( CSTE )
                            dbg.enterAlt(1);

                            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:104:35: CSTE
                            {
                            dbg.location(104,35);
                            match(input,CSTE,FOLLOW_CSTE_in_typ567); if (state.failed) return retval;

                            }

                            dbg.location(104,41);
                            match(input,30,FOLLOW_30_in_typ570); if (state.failed) return retval;
                            dbg.location(104,46);
                            match(input,Types,FOLLOW_Types_in_typ572); if (state.failed) return retval;

                            }
                            break;
                        case 3 :
                            dbg.enterAlt(3);

                            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:104:55: structsimple
                            {
                            dbg.location(104,55);
                            pushFollow(FOLLOW_structsimple_in_typ577);
                            structsimple();

                            state._fsp--;
                            if (state.failed) return retval;

                            }
                            break;
                        case 4 :
                            dbg.enterAlt(4);

                            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:104:70: strucrcomplexe
                            {
                            dbg.location(104,70);
                            pushFollow(FOLLOW_strucrcomplexe_in_typ581);
                            strucrcomplexe();

                            state._fsp--;
                            if (state.failed) return retval;

                            }
                            break;

                    }
                    } finally {dbg.exitSubRule(32);}

                    dbg.location(104,87);
                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:104:87: ( 'header' )?
                    int alt33=2;
                    try { dbg.enterSubRule(33);
                    try { dbg.enterDecision(33);

                    int LA33_0 = input.LA(1);

                    if ( (LA33_0==33) ) {
                        alt33=1;
                    }
                    } finally {dbg.exitDecision(33);}

                    switch (alt33) {
                        case 1 :
                            dbg.enterAlt(1);

                            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:0:0: 'header'
                            {
                            dbg.location(104,87);
                            match(input,33,FOLLOW_33_in_typ585); if (state.failed) return retval;

                            }
                            break;

                    }
                    } finally {dbg.exitSubRule(33);}

                    dbg.location(104,97);
                    match(input,23,FOLLOW_23_in_typ588); if (state.failed) return retval;
                    dbg.location(104,101);
                    match(input,Types,FOLLOW_Types_in_typ590); if (state.failed) return retval;
                    dbg.location(104,107);
                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:104:107: ( ',' Types )*
                    try { dbg.enterSubRule(34);

                    loop34:
                    do {
                        int alt34=2;
                        try { dbg.enterDecision(34);

                        int LA34_0 = input.LA(1);

                        if ( (LA34_0==34) ) {
                            alt34=1;
                        }


                        } finally {dbg.exitDecision(34);}

                        switch (alt34) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:104:109: ',' Types
                    	    {
                    	    dbg.location(104,109);
                    	    match(input,34,FOLLOW_34_in_typ594); if (state.failed) return retval;
                    	    dbg.location(104,113);
                    	    match(input,Types,FOLLOW_Types_in_typ596); if (state.failed) return retval;

                    	    }
                    	    break;

                    	default :
                    	    break loop34;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(34);}

                    dbg.location(104,121);
                    match(input,24,FOLLOW_24_in_typ600); if (state.failed) return retval;
                    dbg.location(104,125);
                    match(input,35,FOLLOW_35_in_typ602); if (state.failed) return retval;
                    dbg.location(104,134);
                    pushFollow(FOLLOW_li_in_typ604);
                    li();

                    state._fsp--;
                    if (state.failed) return retval;

                    }
                    break;

            }
            retval.stop = input.LT(-1);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        dbg.location(104, 137);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "typ");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "typ"


    // $ANTLR start "structsimple"
    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:106:1: structsimple : ( 'structure' )? '(' Types ( ',' Types )* ')' ;
    public final void structsimple() throws RecognitionException {
        try { dbg.enterRule(getGrammarFileName(), "structsimple");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(106, 1);

        try {
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:107:3: ( ( 'structure' )? '(' Types ( ',' Types )* ')' )
            dbg.enterAlt(1);

            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:107:5: ( 'structure' )? '(' Types ( ',' Types )* ')'
            {
            dbg.location(107,5);
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:107:5: ( 'structure' )?
            int alt36=2;
            try { dbg.enterSubRule(36);
            try { dbg.enterDecision(36);

            int LA36_0 = input.LA(1);

            if ( (LA36_0==36) ) {
                alt36=1;
            }
            } finally {dbg.exitDecision(36);}

            switch (alt36) {
                case 1 :
                    dbg.enterAlt(1);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:0:0: 'structure'
                    {
                    dbg.location(107,5);
                    match(input,36,FOLLOW_36_in_structsimple620); if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(36);}

            dbg.location(107,18);
            match(input,23,FOLLOW_23_in_structsimple623); if (state.failed) return ;
            dbg.location(107,22);
            match(input,Types,FOLLOW_Types_in_structsimple625); if (state.failed) return ;
            dbg.location(107,28);
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:107:28: ( ',' Types )*
            try { dbg.enterSubRule(37);

            loop37:
            do {
                int alt37=2;
                try { dbg.enterDecision(37);

                int LA37_0 = input.LA(1);

                if ( (LA37_0==34) ) {
                    alt37=1;
                }


                } finally {dbg.exitDecision(37);}

                switch (alt37) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:107:30: ',' Types
            	    {
            	    dbg.location(107,30);
            	    match(input,34,FOLLOW_34_in_structsimple629); if (state.failed) return ;
            	    dbg.location(107,34);
            	    match(input,Types,FOLLOW_Types_in_structsimple631); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop37;
                }
            } while (true);
            } finally {dbg.exitSubRule(37);}

            dbg.location(107,43);
            match(input,24,FOLLOW_24_in_structsimple636); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        dbg.location(107, 46);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "structsimple");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "structsimple"


    // $ANTLR start "strucrcomplexe"
    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:109:1: strucrcomplexe : ( 'structure' )? '(' ( Types | 'vector' ( CSTE ) 'of' Types ) ( ',' ( Types | 'vector' ( CSTE ) 'of' Types ) )* ')' ;
    public final void strucrcomplexe() throws RecognitionException {
        try { dbg.enterRule(getGrammarFileName(), "strucrcomplexe");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(109, 1);

        try {
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:110:3: ( ( 'structure' )? '(' ( Types | 'vector' ( CSTE ) 'of' Types ) ( ',' ( Types | 'vector' ( CSTE ) 'of' Types ) )* ')' )
            dbg.enterAlt(1);

            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:110:4: ( 'structure' )? '(' ( Types | 'vector' ( CSTE ) 'of' Types ) ( ',' ( Types | 'vector' ( CSTE ) 'of' Types ) )* ')'
            {
            dbg.location(110,4);
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:110:4: ( 'structure' )?
            int alt38=2;
            try { dbg.enterSubRule(38);
            try { dbg.enterDecision(38);

            int LA38_0 = input.LA(1);

            if ( (LA38_0==36) ) {
                alt38=1;
            }
            } finally {dbg.exitDecision(38);}

            switch (alt38) {
                case 1 :
                    dbg.enterAlt(1);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:0:0: 'structure'
                    {
                    dbg.location(110,4);
                    match(input,36,FOLLOW_36_in_strucrcomplexe646); if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(38);}

            dbg.location(110,17);
            match(input,23,FOLLOW_23_in_strucrcomplexe649); if (state.failed) return ;
            dbg.location(110,21);
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:110:21: ( Types | 'vector' ( CSTE ) 'of' Types )
            int alt39=2;
            try { dbg.enterSubRule(39);
            try { dbg.enterDecision(39);

            int LA39_0 = input.LA(1);

            if ( (LA39_0==Types) ) {
                alt39=1;
            }
            else if ( (LA39_0==32) ) {
                alt39=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 39, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(39);}

            switch (alt39) {
                case 1 :
                    dbg.enterAlt(1);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:110:23: Types
                    {
                    dbg.location(110,23);
                    match(input,Types,FOLLOW_Types_in_strucrcomplexe653); if (state.failed) return ;

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:110:31: 'vector' ( CSTE ) 'of' Types
                    {
                    dbg.location(110,31);
                    match(input,32,FOLLOW_32_in_strucrcomplexe657); if (state.failed) return ;
                    dbg.location(110,40);
                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:110:40: ( CSTE )
                    dbg.enterAlt(1);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:110:41: CSTE
                    {
                    dbg.location(110,41);
                    match(input,CSTE,FOLLOW_CSTE_in_strucrcomplexe660); if (state.failed) return ;

                    }

                    dbg.location(110,47);
                    match(input,30,FOLLOW_30_in_strucrcomplexe663); if (state.failed) return ;
                    dbg.location(110,52);
                    match(input,Types,FOLLOW_Types_in_strucrcomplexe665); if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(39);}

            dbg.location(110,60);
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:110:60: ( ',' ( Types | 'vector' ( CSTE ) 'of' Types ) )*
            try { dbg.enterSubRule(41);

            loop41:
            do {
                int alt41=2;
                try { dbg.enterDecision(41);

                int LA41_0 = input.LA(1);

                if ( (LA41_0==34) ) {
                    alt41=1;
                }


                } finally {dbg.exitDecision(41);}

                switch (alt41) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:110:62: ',' ( Types | 'vector' ( CSTE ) 'of' Types )
            	    {
            	    dbg.location(110,62);
            	    match(input,34,FOLLOW_34_in_strucrcomplexe671); if (state.failed) return ;
            	    dbg.location(110,66);
            	    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:110:66: ( Types | 'vector' ( CSTE ) 'of' Types )
            	    int alt40=2;
            	    try { dbg.enterSubRule(40);
            	    try { dbg.enterDecision(40);

            	    int LA40_0 = input.LA(1);

            	    if ( (LA40_0==Types) ) {
            	        alt40=1;
            	    }
            	    else if ( (LA40_0==32) ) {
            	        alt40=2;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return ;}
            	        NoViableAltException nvae =
            	            new NoViableAltException("", 40, 0, input);

            	        dbg.recognitionException(nvae);
            	        throw nvae;
            	    }
            	    } finally {dbg.exitDecision(40);}

            	    switch (alt40) {
            	        case 1 :
            	            dbg.enterAlt(1);

            	            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:110:68: Types
            	            {
            	            dbg.location(110,68);
            	            match(input,Types,FOLLOW_Types_in_strucrcomplexe675); if (state.failed) return ;

            	            }
            	            break;
            	        case 2 :
            	            dbg.enterAlt(2);

            	            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:110:76: 'vector' ( CSTE ) 'of' Types
            	            {
            	            dbg.location(110,76);
            	            match(input,32,FOLLOW_32_in_strucrcomplexe679); if (state.failed) return ;
            	            dbg.location(110,85);
            	            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:110:85: ( CSTE )
            	            dbg.enterAlt(1);

            	            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:110:86: CSTE
            	            {
            	            dbg.location(110,86);
            	            match(input,CSTE,FOLLOW_CSTE_in_strucrcomplexe682); if (state.failed) return ;

            	            }

            	            dbg.location(110,92);
            	            match(input,30,FOLLOW_30_in_strucrcomplexe685); if (state.failed) return ;
            	            dbg.location(110,97);
            	            match(input,Types,FOLLOW_Types_in_strucrcomplexe687); if (state.failed) return ;

            	            }
            	            break;

            	    }
            	    } finally {dbg.exitSubRule(40);}


            	    }
            	    break;

            	default :
            	    break loop41;
                }
            } while (true);
            } finally {dbg.exitSubRule(41);}

            dbg.location(110,109);
            match(input,24,FOLLOW_24_in_strucrcomplexe695); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        dbg.location(110, 112);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "strucrcomplexe");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "strucrcomplexe"


    // $ANTLR start "typecomp"
    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:112:1: typecomp : ( 'arm' ( CSTE ) | 'vector' '(' listecste ')' | Autres );
    public final void typecomp() throws RecognitionException {
        try { dbg.enterRule(getGrammarFileName(), "typecomp");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(112, 1);

        try {
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:113:3: ( 'arm' ( CSTE ) | 'vector' '(' listecste ')' | Autres )
            int alt42=3;
            try { dbg.enterDecision(42);

            switch ( input.LA(1) ) {
            case 37:
                {
                alt42=1;
                }
                break;
            case 32:
                {
                alt42=2;
                }
                break;
            case Autres:
                {
                alt42=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 42, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }

            } finally {dbg.exitDecision(42);}

            switch (alt42) {
                case 1 :
                    dbg.enterAlt(1);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:113:5: 'arm' ( CSTE )
                    {
                    dbg.location(113,5);
                    match(input,37,FOLLOW_37_in_typecomp708); if (state.failed) return ;
                    dbg.location(113,11);
                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:113:11: ( CSTE )
                    dbg.enterAlt(1);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:113:12: CSTE
                    {
                    dbg.location(113,12);
                    match(input,CSTE,FOLLOW_CSTE_in_typecomp711); if (state.failed) return ;

                    }


                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:113:20: 'vector' '(' listecste ')'
                    {
                    dbg.location(113,20);
                    match(input,32,FOLLOW_32_in_typecomp716); if (state.failed) return ;
                    dbg.location(113,29);
                    match(input,23,FOLLOW_23_in_typecomp718); if (state.failed) return ;
                    dbg.location(113,33);
                    pushFollow(FOLLOW_listecste_in_typecomp720);
                    listecste();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(113,43);
                    match(input,24,FOLLOW_24_in_typecomp722); if (state.failed) return ;

                    }
                    break;
                case 3 :
                    dbg.enterAlt(3);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:113:49: Autres
                    {
                    dbg.location(113,49);
                    match(input,Autres,FOLLOW_Autres_in_typecomp726); if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        dbg.location(113, 56);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "typecomp");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "typecomp"


    // $ANTLR start "listecste"
    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:127:1: listecste : CSTE ( ',' CSTE )* ;
    public final void listecste() throws RecognitionException {
        try { dbg.enterRule(getGrammarFileName(), "listecste");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(127, 1);

        try {
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:128:3: ( CSTE ( ',' CSTE )* )
            dbg.enterAlt(1);

            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:128:5: CSTE ( ',' CSTE )*
            {
            dbg.location(128,5);
            match(input,CSTE,FOLLOW_CSTE_in_listecste829); if (state.failed) return ;
            dbg.location(128,10);
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:128:10: ( ',' CSTE )*
            try { dbg.enterSubRule(43);

            loop43:
            do {
                int alt43=2;
                try { dbg.enterDecision(43);

                int LA43_0 = input.LA(1);

                if ( (LA43_0==34) ) {
                    alt43=1;
                }


                } finally {dbg.exitDecision(43);}

                switch (alt43) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:128:12: ',' CSTE
            	    {
            	    dbg.location(128,12);
            	    match(input,34,FOLLOW_34_in_listecste833); if (state.failed) return ;
            	    dbg.location(128,16);
            	    match(input,CSTE,FOLLOW_CSTE_in_listecste835); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop43;
                }
            } while (true);
            } finally {dbg.exitSubRule(43);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        dbg.location(128, 23);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "listecste");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "listecste"


    // $ANTLR start "li"
    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:130:1: li returns [List<VariableDeclare> ids=new List<VariableDeclare>()] : i1= ID ( ',' i2= ID )* ;
    public final List<VariableDeclare> li() throws RecognitionException {
        List<VariableDeclare> ids = new List<VariableDeclare>();

        Token i1=null;
        Token i2=null;

        try { dbg.enterRule(getGrammarFileName(), "li");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(130, 1);

        try {
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:131:3: (i1= ID ( ',' i2= ID )* )
            dbg.enterAlt(1);

            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:131:5: i1= ID ( ',' i2= ID )*
            {
            dbg.location(131,7);
            i1=(Token)match(input,ID,FOLLOW_ID_in_li858); if (state.failed) return ids;
            dbg.location(131,12);
            if ( state.backtracking==0 ) {
              ids.Add(new VariableDeclare(i1));
            }
            dbg.location(131,48);
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:131:48: ( ',' i2= ID )*
            try { dbg.enterSubRule(44);

            loop44:
            do {
                int alt44=2;
                try { dbg.enterDecision(44);

                int LA44_0 = input.LA(1);

                if ( (LA44_0==34) ) {
                    int LA44_2 = input.LA(2);

                    if ( (LA44_2==ID) ) {
                        int LA44_3 = input.LA(3);

                        if ( (synpred49_GrammaireZ2Enu()) ) {
                            alt44=1;
                        }


                    }


                }


                } finally {dbg.exitDecision(44);}

                switch (alt44) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:131:50: ',' i2= ID
            	    {
            	    dbg.location(131,50);
            	    match(input,34,FOLLOW_34_in_li865); if (state.failed) return ids;
            	    dbg.location(131,56);
            	    i2=(Token)match(input,ID,FOLLOW_ID_in_li869); if (state.failed) return ids;
            	    dbg.location(131,60);
            	    if ( state.backtracking==0 ) {
            	      ids.Add(new VariableDeclare(i2));
            	    }

            	    }
            	    break;

            	default :
            	    break loop44;
                }
            } while (true);
            } finally {dbg.exitSubRule(44);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        dbg.location(131, 98);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "li");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ids;
    }
    // $ANTLR end "li"


    // $ANTLR start "lis"
    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:133:1: lis : inst ( ';' inst )* ;
    public final void lis() throws RecognitionException {
        try { dbg.enterRule(getGrammarFileName(), "lis");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(133, 1);

        try {
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:134:3: ( inst ( ';' inst )* )
            dbg.enterAlt(1);

            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:134:5: inst ( ';' inst )*
            {
            dbg.location(134,5);
            pushFollow(FOLLOW_inst_in_lis888);
            inst();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(134,10);
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:134:10: ( ';' inst )*
            try { dbg.enterSubRule(45);

            loop45:
            do {
                int alt45=2;
                try { dbg.enterDecision(45);

                int LA45_0 = input.LA(1);

                if ( (LA45_0==21) ) {
                    alt45=1;
                }


                } finally {dbg.exitDecision(45);}

                switch (alt45) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:134:12: ';' inst
            	    {
            	    dbg.location(134,12);
            	    match(input,21,FOLLOW_21_in_lis892); if (state.failed) return ;
            	    dbg.location(134,16);
            	    pushFollow(FOLLOW_inst_in_lis894);
            	    inst();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop45;
                }
            } while (true);
            } finally {dbg.exitSubRule(45);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        dbg.location(134, 23);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "lis");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "lis"


    // $ANTLR start "inst"
    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:136:1: inst : ( ID ':=' exp | 'tantque' exp ( ':' )? lis ( 'endwhile' | 'ewhile' ) | 'if' exp ( ':' )? lis ( 'else' lis )? ( 'endif' | 'eif' ) | 'for' ID ':=' exp ',' exp ( ',' exp )? ( ':' )? lis ( 'endfor' | 'efor' ) | 'call' ID ( '(' exp ( ',' exp )* ')' )? | 'read' '(' ID ( ',' ID )* ')' | 'write' '(' exp ( ',' exp )* ')' | 'open' '(' exp ',' exp ',' exp ')' | 'ass_item' '(' exp ( exp ( ',' exp )* )? ',' exp ')' | Proc26 '(' exp ')' | Proc53 '(' ID ',' ID ')' | Proc50 '(' exp ',' exp ')' | Proc39 '(' ID ',' '[' ( exp | '[' exp ( ',' exp )* ']' ) ( ',' ( exp | '[' exp ( ',' exp )* ']' ) )* ']' ')' | Proc30 '(' exp ',' exp ',' exp ')' );
    public final void inst() throws RecognitionException {
        try { dbg.enterRule(getGrammarFileName(), "inst");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(136, 1);

        try {
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:137:3: ( ID ':=' exp | 'tantque' exp ( ':' )? lis ( 'endwhile' | 'ewhile' ) | 'if' exp ( ':' )? lis ( 'else' lis )? ( 'endif' | 'eif' ) | 'for' ID ':=' exp ',' exp ( ',' exp )? ( ':' )? lis ( 'endfor' | 'efor' ) | 'call' ID ( '(' exp ( ',' exp )* ')' )? | 'read' '(' ID ( ',' ID )* ')' | 'write' '(' exp ( ',' exp )* ')' | 'open' '(' exp ',' exp ',' exp ')' | 'ass_item' '(' exp ( exp ( ',' exp )* )? ',' exp ')' | Proc26 '(' exp ')' | Proc53 '(' ID ',' ID ')' | Proc50 '(' exp ',' exp ')' | Proc39 '(' ID ',' '[' ( exp | '[' exp ( ',' exp )* ']' ) ( ',' ( exp | '[' exp ( ',' exp )* ']' ) )* ']' ')' | Proc30 '(' exp ',' exp ',' exp ')' )
            int alt62=14;
            try { dbg.enterDecision(62);

            switch ( input.LA(1) ) {
            case ID:
                {
                alt62=1;
                }
                break;
            case 39:
                {
                alt62=2;
                }
                break;
            case 42:
                {
                alt62=3;
                }
                break;
            case 46:
                {
                alt62=4;
                }
                break;
            case 49:
                {
                alt62=5;
                }
                break;
            case 50:
                {
                alt62=6;
                }
                break;
            case 51:
                {
                alt62=7;
                }
                break;
            case 52:
                {
                alt62=8;
                }
                break;
            case 53:
                {
                alt62=9;
                }
                break;
            case Proc26:
                {
                alt62=10;
                }
                break;
            case Proc53:
                {
                alt62=11;
                }
                break;
            case Proc50:
                {
                alt62=12;
                }
                break;
            case Proc39:
                {
                alt62=13;
                }
                break;
            case Proc30:
                {
                alt62=14;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 62, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }

            } finally {dbg.exitDecision(62);}

            switch (alt62) {
                case 1 :
                    dbg.enterAlt(1);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:137:5: ID ':=' exp
                    {
                    dbg.location(137,5);
                    match(input,ID,FOLLOW_ID_in_inst914); if (state.failed) return ;
                    dbg.location(137,8);
                    match(input,38,FOLLOW_38_in_inst916); if (state.failed) return ;
                    dbg.location(137,13);
                    pushFollow(FOLLOW_exp_in_inst918);
                    exp();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:138:3: 'tantque' exp ( ':' )? lis ( 'endwhile' | 'ewhile' )
                    {
                    dbg.location(138,3);
                    match(input,39,FOLLOW_39_in_inst925); if (state.failed) return ;
                    dbg.location(138,13);
                    pushFollow(FOLLOW_exp_in_inst927);
                    exp();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(138,18);
                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:138:18: ( ':' )?
                    int alt46=2;
                    try { dbg.enterSubRule(46);
                    try { dbg.enterDecision(46);

                    int LA46_0 = input.LA(1);

                    if ( (LA46_0==26) ) {
                        alt46=1;
                    }
                    } finally {dbg.exitDecision(46);}

                    switch (alt46) {
                        case 1 :
                            dbg.enterAlt(1);

                            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:0:0: ':'
                            {
                            dbg.location(138,18);
                            match(input,26,FOLLOW_26_in_inst930); if (state.failed) return ;

                            }
                            break;

                    }
                    } finally {dbg.exitSubRule(46);}

                    dbg.location(138,24);
                    pushFollow(FOLLOW_lis_in_inst934);
                    lis();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(138,28);
                    if ( (input.LA(1)>=40 && input.LA(1)<=41) ) {
                        input.consume();
                        state.errorRecovery=false;state.failed=false;
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return ;}
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        dbg.recognitionException(mse);
                        throw mse;
                    }


                    }
                    break;
                case 3 :
                    dbg.enterAlt(3);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:139:3: 'if' exp ( ':' )? lis ( 'else' lis )? ( 'endif' | 'eif' )
                    {
                    dbg.location(139,3);
                    match(input,42,FOLLOW_42_in_inst949); if (state.failed) return ;
                    dbg.location(139,8);
                    pushFollow(FOLLOW_exp_in_inst951);
                    exp();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(139,12);
                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:139:12: ( ':' )?
                    int alt47=2;
                    try { dbg.enterSubRule(47);
                    try { dbg.enterDecision(47);

                    int LA47_0 = input.LA(1);

                    if ( (LA47_0==26) ) {
                        alt47=1;
                    }
                    } finally {dbg.exitDecision(47);}

                    switch (alt47) {
                        case 1 :
                            dbg.enterAlt(1);

                            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:0:0: ':'
                            {
                            dbg.location(139,12);
                            match(input,26,FOLLOW_26_in_inst953); if (state.failed) return ;

                            }
                            break;

                    }
                    } finally {dbg.exitSubRule(47);}

                    dbg.location(139,18);
                    pushFollow(FOLLOW_lis_in_inst957);
                    lis();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(139,23);
                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:139:23: ( 'else' lis )?
                    int alt48=2;
                    try { dbg.enterSubRule(48);
                    try { dbg.enterDecision(48);

                    int LA48_0 = input.LA(1);

                    if ( (LA48_0==43) ) {
                        alt48=1;
                    }
                    } finally {dbg.exitDecision(48);}

                    switch (alt48) {
                        case 1 :
                            dbg.enterAlt(1);

                            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:139:24: 'else' lis
                            {
                            dbg.location(139,24);
                            match(input,43,FOLLOW_43_in_inst961); if (state.failed) return ;
                            dbg.location(139,32);
                            pushFollow(FOLLOW_lis_in_inst964);
                            lis();

                            state._fsp--;
                            if (state.failed) return ;

                            }
                            break;

                    }
                    } finally {dbg.exitSubRule(48);}

                    dbg.location(139,38);
                    if ( (input.LA(1)>=44 && input.LA(1)<=45) ) {
                        input.consume();
                        state.errorRecovery=false;state.failed=false;
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return ;}
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        dbg.recognitionException(mse);
                        throw mse;
                    }


                    }
                    break;
                case 4 :
                    dbg.enterAlt(4);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:140:3: 'for' ID ':=' exp ',' exp ( ',' exp )? ( ':' )? lis ( 'endfor' | 'efor' )
                    {
                    dbg.location(140,3);
                    match(input,46,FOLLOW_46_in_inst998); if (state.failed) return ;
                    dbg.location(140,9);
                    match(input,ID,FOLLOW_ID_in_inst1000); if (state.failed) return ;
                    dbg.location(140,12);
                    match(input,38,FOLLOW_38_in_inst1002); if (state.failed) return ;
                    dbg.location(140,17);
                    pushFollow(FOLLOW_exp_in_inst1004);
                    exp();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(140,21);
                    match(input,34,FOLLOW_34_in_inst1006); if (state.failed) return ;
                    dbg.location(140,25);
                    pushFollow(FOLLOW_exp_in_inst1008);
                    exp();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(140,29);
                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:140:29: ( ',' exp )?
                    int alt49=2;
                    try { dbg.enterSubRule(49);
                    try { dbg.enterDecision(49);

                    int LA49_0 = input.LA(1);

                    if ( (LA49_0==34) ) {
                        alt49=1;
                    }
                    } finally {dbg.exitDecision(49);}

                    switch (alt49) {
                        case 1 :
                            dbg.enterAlt(1);

                            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:140:30: ',' exp
                            {
                            dbg.location(140,30);
                            match(input,34,FOLLOW_34_in_inst1011); if (state.failed) return ;
                            dbg.location(140,34);
                            pushFollow(FOLLOW_exp_in_inst1013);
                            exp();

                            state._fsp--;
                            if (state.failed) return ;

                            }
                            break;

                    }
                    } finally {dbg.exitSubRule(49);}

                    dbg.location(140,40);
                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:140:40: ( ':' )?
                    int alt50=2;
                    try { dbg.enterSubRule(50);
                    try { dbg.enterDecision(50);

                    int LA50_0 = input.LA(1);

                    if ( (LA50_0==26) ) {
                        alt50=1;
                    }
                    } finally {dbg.exitDecision(50);}

                    switch (alt50) {
                        case 1 :
                            dbg.enterAlt(1);

                            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:0:0: ':'
                            {
                            dbg.location(140,40);
                            match(input,26,FOLLOW_26_in_inst1017); if (state.failed) return ;

                            }
                            break;

                    }
                    } finally {dbg.exitSubRule(50);}

                    dbg.location(140,46);
                    pushFollow(FOLLOW_lis_in_inst1021);
                    lis();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(140,51);
                    if ( (input.LA(1)>=47 && input.LA(1)<=48) ) {
                        input.consume();
                        state.errorRecovery=false;state.failed=false;
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return ;}
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        dbg.recognitionException(mse);
                        throw mse;
                    }


                    }
                    break;
                case 5 :
                    dbg.enterAlt(5);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:141:3: 'call' ID ( '(' exp ( ',' exp )* ')' )?
                    {
                    dbg.location(141,3);
                    match(input,49,FOLLOW_49_in_inst1036); if (state.failed) return ;
                    dbg.location(141,10);
                    match(input,ID,FOLLOW_ID_in_inst1038); if (state.failed) return ;
                    dbg.location(141,13);
                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:141:13: ( '(' exp ( ',' exp )* ')' )?
                    int alt52=2;
                    try { dbg.enterSubRule(52);
                    try { dbg.enterDecision(52);

                    int LA52_0 = input.LA(1);

                    if ( (LA52_0==23) ) {
                        alt52=1;
                    }
                    } finally {dbg.exitDecision(52);}

                    switch (alt52) {
                        case 1 :
                            dbg.enterAlt(1);

                            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:141:14: '(' exp ( ',' exp )* ')'
                            {
                            dbg.location(141,14);
                            match(input,23,FOLLOW_23_in_inst1041); if (state.failed) return ;
                            dbg.location(141,17);
                            pushFollow(FOLLOW_exp_in_inst1042);
                            exp();

                            state._fsp--;
                            if (state.failed) return ;
                            dbg.location(141,21);
                            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:141:21: ( ',' exp )*
                            try { dbg.enterSubRule(51);

                            loop51:
                            do {
                                int alt51=2;
                                try { dbg.enterDecision(51);

                                int LA51_0 = input.LA(1);

                                if ( (LA51_0==34) ) {
                                    alt51=1;
                                }


                                } finally {dbg.exitDecision(51);}

                                switch (alt51) {
                            	case 1 :
                            	    dbg.enterAlt(1);

                            	    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:141:22: ',' exp
                            	    {
                            	    dbg.location(141,22);
                            	    match(input,34,FOLLOW_34_in_inst1045); if (state.failed) return ;
                            	    dbg.location(141,25);
                            	    pushFollow(FOLLOW_exp_in_inst1046);
                            	    exp();

                            	    state._fsp--;
                            	    if (state.failed) return ;

                            	    }
                            	    break;

                            	default :
                            	    break loop51;
                                }
                            } while (true);
                            } finally {dbg.exitSubRule(51);}

                            dbg.location(141,30);
                            match(input,24,FOLLOW_24_in_inst1049); if (state.failed) return ;

                            }
                            break;

                    }
                    } finally {dbg.exitSubRule(52);}


                    }
                    break;
                case 6 :
                    dbg.enterAlt(6);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:142:3: 'read' '(' ID ( ',' ID )* ')'
                    {
                    dbg.location(142,3);
                    match(input,50,FOLLOW_50_in_inst1057); if (state.failed) return ;
                    dbg.location(142,10);
                    match(input,23,FOLLOW_23_in_inst1059); if (state.failed) return ;
                    dbg.location(142,14);
                    match(input,ID,FOLLOW_ID_in_inst1061); if (state.failed) return ;
                    dbg.location(142,17);
                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:142:17: ( ',' ID )*
                    try { dbg.enterSubRule(53);

                    loop53:
                    do {
                        int alt53=2;
                        try { dbg.enterDecision(53);

                        int LA53_0 = input.LA(1);

                        if ( (LA53_0==34) ) {
                            alt53=1;
                        }


                        } finally {dbg.exitDecision(53);}

                        switch (alt53) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:142:18: ',' ID
                    	    {
                    	    dbg.location(142,18);
                    	    match(input,34,FOLLOW_34_in_inst1064); if (state.failed) return ;
                    	    dbg.location(142,22);
                    	    match(input,ID,FOLLOW_ID_in_inst1066); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop53;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(53);}

                    dbg.location(142,28);
                    match(input,24,FOLLOW_24_in_inst1071); if (state.failed) return ;

                    }
                    break;
                case 7 :
                    dbg.enterAlt(7);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:143:3: 'write' '(' exp ( ',' exp )* ')'
                    {
                    dbg.location(143,3);
                    match(input,51,FOLLOW_51_in_inst1097); if (state.failed) return ;
                    dbg.location(143,11);
                    match(input,23,FOLLOW_23_in_inst1099); if (state.failed) return ;
                    dbg.location(143,15);
                    pushFollow(FOLLOW_exp_in_inst1101);
                    exp();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(143,19);
                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:143:19: ( ',' exp )*
                    try { dbg.enterSubRule(54);

                    loop54:
                    do {
                        int alt54=2;
                        try { dbg.enterDecision(54);

                        int LA54_0 = input.LA(1);

                        if ( (LA54_0==34) ) {
                            alt54=1;
                        }


                        } finally {dbg.exitDecision(54);}

                        switch (alt54) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:143:20: ',' exp
                    	    {
                    	    dbg.location(143,20);
                    	    match(input,34,FOLLOW_34_in_inst1104); if (state.failed) return ;
                    	    dbg.location(143,23);
                    	    pushFollow(FOLLOW_exp_in_inst1105);
                    	    exp();

                    	    state._fsp--;
                    	    if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop54;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(54);}

                    dbg.location(143,29);
                    match(input,24,FOLLOW_24_in_inst1109); if (state.failed) return ;

                    }
                    break;
                case 8 :
                    dbg.enterAlt(8);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:144:3: 'open' '(' exp ',' exp ',' exp ')'
                    {
                    dbg.location(144,3);
                    match(input,52,FOLLOW_52_in_inst1116); if (state.failed) return ;
                    dbg.location(144,10);
                    match(input,23,FOLLOW_23_in_inst1118); if (state.failed) return ;
                    dbg.location(144,14);
                    pushFollow(FOLLOW_exp_in_inst1120);
                    exp();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(144,18);
                    match(input,34,FOLLOW_34_in_inst1122); if (state.failed) return ;
                    dbg.location(144,22);
                    pushFollow(FOLLOW_exp_in_inst1124);
                    exp();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(144,26);
                    match(input,34,FOLLOW_34_in_inst1126); if (state.failed) return ;
                    dbg.location(144,30);
                    pushFollow(FOLLOW_exp_in_inst1128);
                    exp();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(144,34);
                    match(input,24,FOLLOW_24_in_inst1130); if (state.failed) return ;

                    }
                    break;
                case 9 :
                    dbg.enterAlt(9);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:145:3: 'ass_item' '(' exp ( exp ( ',' exp )* )? ',' exp ')'
                    {
                    dbg.location(145,3);
                    match(input,53,FOLLOW_53_in_inst1136); if (state.failed) return ;
                    dbg.location(145,14);
                    match(input,23,FOLLOW_23_in_inst1138); if (state.failed) return ;
                    dbg.location(145,18);
                    pushFollow(FOLLOW_exp_in_inst1140);
                    exp();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(145,22);
                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:145:22: ( exp ( ',' exp )* )?
                    int alt56=2;
                    try { dbg.enterSubRule(56);
                    try { dbg.enterDecision(56);

                    int LA56_0 = input.LA(1);

                    if ( (LA56_0==ID||LA56_0==CSTE||LA56_0==23||LA56_0==25||(LA56_0>=56 && LA56_0<=57)||(LA56_0>=59 && LA56_0<=62)) ) {
                        alt56=1;
                    }
                    } finally {dbg.exitDecision(56);}

                    switch (alt56) {
                        case 1 :
                            dbg.enterAlt(1);

                            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:145:24: exp ( ',' exp )*
                            {
                            dbg.location(145,24);
                            pushFollow(FOLLOW_exp_in_inst1144);
                            exp();

                            state._fsp--;
                            if (state.failed) return ;
                            dbg.location(145,28);
                            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:145:28: ( ',' exp )*
                            try { dbg.enterSubRule(55);

                            loop55:
                            do {
                                int alt55=2;
                                try { dbg.enterDecision(55);

                                int LA55_0 = input.LA(1);

                                if ( (LA55_0==34) ) {
                                    int LA55_1 = input.LA(2);

                                    if ( (synpred71_GrammaireZ2Enu()) ) {
                                        alt55=1;
                                    }


                                }


                                } finally {dbg.exitDecision(55);}

                                switch (alt55) {
                            	case 1 :
                            	    dbg.enterAlt(1);

                            	    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:145:30: ',' exp
                            	    {
                            	    dbg.location(145,30);
                            	    match(input,34,FOLLOW_34_in_inst1148); if (state.failed) return ;
                            	    dbg.location(145,34);
                            	    pushFollow(FOLLOW_exp_in_inst1150);
                            	    exp();

                            	    state._fsp--;
                            	    if (state.failed) return ;

                            	    }
                            	    break;

                            	default :
                            	    break loop55;
                                }
                            } while (true);
                            } finally {dbg.exitSubRule(55);}


                            }
                            break;

                    }
                    } finally {dbg.exitSubRule(56);}

                    dbg.location(145,45);
                    match(input,34,FOLLOW_34_in_inst1159); if (state.failed) return ;
                    dbg.location(145,49);
                    pushFollow(FOLLOW_exp_in_inst1161);
                    exp();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(145,53);
                    match(input,24,FOLLOW_24_in_inst1163); if (state.failed) return ;

                    }
                    break;
                case 10 :
                    dbg.enterAlt(10);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:146:3: Proc26 '(' exp ')'
                    {
                    dbg.location(146,3);
                    match(input,Proc26,FOLLOW_Proc26_in_inst1169); if (state.failed) return ;
                    dbg.location(146,10);
                    match(input,23,FOLLOW_23_in_inst1171); if (state.failed) return ;
                    dbg.location(146,14);
                    pushFollow(FOLLOW_exp_in_inst1173);
                    exp();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(146,18);
                    match(input,24,FOLLOW_24_in_inst1175); if (state.failed) return ;

                    }
                    break;
                case 11 :
                    dbg.enterAlt(11);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:147:3: Proc53 '(' ID ',' ID ')'
                    {
                    dbg.location(147,3);
                    match(input,Proc53,FOLLOW_Proc53_in_inst1184); if (state.failed) return ;
                    dbg.location(147,10);
                    match(input,23,FOLLOW_23_in_inst1186); if (state.failed) return ;
                    dbg.location(147,14);
                    match(input,ID,FOLLOW_ID_in_inst1188); if (state.failed) return ;
                    dbg.location(147,17);
                    match(input,34,FOLLOW_34_in_inst1190); if (state.failed) return ;
                    dbg.location(147,21);
                    match(input,ID,FOLLOW_ID_in_inst1192); if (state.failed) return ;
                    dbg.location(147,24);
                    match(input,24,FOLLOW_24_in_inst1194); if (state.failed) return ;

                    }
                    break;
                case 12 :
                    dbg.enterAlt(12);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:148:3: Proc50 '(' exp ',' exp ')'
                    {
                    dbg.location(148,3);
                    match(input,Proc50,FOLLOW_Proc50_in_inst1203); if (state.failed) return ;
                    dbg.location(148,10);
                    match(input,23,FOLLOW_23_in_inst1205); if (state.failed) return ;
                    dbg.location(148,14);
                    pushFollow(FOLLOW_exp_in_inst1207);
                    exp();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(148,18);
                    match(input,34,FOLLOW_34_in_inst1209); if (state.failed) return ;
                    dbg.location(148,22);
                    pushFollow(FOLLOW_exp_in_inst1211);
                    exp();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(148,26);
                    match(input,24,FOLLOW_24_in_inst1213); if (state.failed) return ;

                    }
                    break;
                case 13 :
                    dbg.enterAlt(13);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:149:3: Proc39 '(' ID ',' '[' ( exp | '[' exp ( ',' exp )* ']' ) ( ',' ( exp | '[' exp ( ',' exp )* ']' ) )* ']' ')'
                    {
                    dbg.location(149,3);
                    match(input,Proc39,FOLLOW_Proc39_in_inst1240); if (state.failed) return ;
                    dbg.location(149,10);
                    match(input,23,FOLLOW_23_in_inst1242); if (state.failed) return ;
                    dbg.location(149,14);
                    match(input,ID,FOLLOW_ID_in_inst1244); if (state.failed) return ;
                    dbg.location(149,17);
                    match(input,34,FOLLOW_34_in_inst1246); if (state.failed) return ;
                    dbg.location(149,21);
                    match(input,54,FOLLOW_54_in_inst1248); if (state.failed) return ;
                    dbg.location(149,25);
                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:149:25: ( exp | '[' exp ( ',' exp )* ']' )
                    int alt58=2;
                    try { dbg.enterSubRule(58);
                    try { dbg.enterDecision(58);

                    int LA58_0 = input.LA(1);

                    if ( (LA58_0==ID||LA58_0==CSTE||LA58_0==23||LA58_0==25||(LA58_0>=56 && LA58_0<=57)||(LA58_0>=59 && LA58_0<=62)) ) {
                        alt58=1;
                    }
                    else if ( (LA58_0==54) ) {
                        alt58=2;
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return ;}
                        NoViableAltException nvae =
                            new NoViableAltException("", 58, 0, input);

                        dbg.recognitionException(nvae);
                        throw nvae;
                    }
                    } finally {dbg.exitDecision(58);}

                    switch (alt58) {
                        case 1 :
                            dbg.enterAlt(1);

                            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:149:27: exp
                            {
                            dbg.location(149,27);
                            pushFollow(FOLLOW_exp_in_inst1252);
                            exp();

                            state._fsp--;
                            if (state.failed) return ;

                            }
                            break;
                        case 2 :
                            dbg.enterAlt(2);

                            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:149:33: '[' exp ( ',' exp )* ']'
                            {
                            dbg.location(149,33);
                            match(input,54,FOLLOW_54_in_inst1256); if (state.failed) return ;
                            dbg.location(149,37);
                            pushFollow(FOLLOW_exp_in_inst1258);
                            exp();

                            state._fsp--;
                            if (state.failed) return ;
                            dbg.location(149,41);
                            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:149:41: ( ',' exp )*
                            try { dbg.enterSubRule(57);

                            loop57:
                            do {
                                int alt57=2;
                                try { dbg.enterDecision(57);

                                int LA57_0 = input.LA(1);

                                if ( (LA57_0==34) ) {
                                    alt57=1;
                                }


                                } finally {dbg.exitDecision(57);}

                                switch (alt57) {
                            	case 1 :
                            	    dbg.enterAlt(1);

                            	    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:149:43: ',' exp
                            	    {
                            	    dbg.location(149,43);
                            	    match(input,34,FOLLOW_34_in_inst1262); if (state.failed) return ;
                            	    dbg.location(149,47);
                            	    pushFollow(FOLLOW_exp_in_inst1264);
                            	    exp();

                            	    state._fsp--;
                            	    if (state.failed) return ;

                            	    }
                            	    break;

                            	default :
                            	    break loop57;
                                }
                            } while (true);
                            } finally {dbg.exitSubRule(57);}

                            dbg.location(149,55);
                            match(input,55,FOLLOW_55_in_inst1270); if (state.failed) return ;

                            }
                            break;

                    }
                    } finally {dbg.exitSubRule(58);}

                    dbg.location(149,62);
                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:149:62: ( ',' ( exp | '[' exp ( ',' exp )* ']' ) )*
                    try { dbg.enterSubRule(61);

                    loop61:
                    do {
                        int alt61=2;
                        try { dbg.enterDecision(61);

                        int LA61_0 = input.LA(1);

                        if ( (LA61_0==34) ) {
                            alt61=1;
                        }


                        } finally {dbg.exitDecision(61);}

                        switch (alt61) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:149:64: ',' ( exp | '[' exp ( ',' exp )* ']' )
                    	    {
                    	    dbg.location(149,64);
                    	    match(input,34,FOLLOW_34_in_inst1277); if (state.failed) return ;
                    	    dbg.location(149,68);
                    	    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:149:68: ( exp | '[' exp ( ',' exp )* ']' )
                    	    int alt60=2;
                    	    try { dbg.enterSubRule(60);
                    	    try { dbg.enterDecision(60);

                    	    int LA60_0 = input.LA(1);

                    	    if ( (LA60_0==ID||LA60_0==CSTE||LA60_0==23||LA60_0==25||(LA60_0>=56 && LA60_0<=57)||(LA60_0>=59 && LA60_0<=62)) ) {
                    	        alt60=1;
                    	    }
                    	    else if ( (LA60_0==54) ) {
                    	        alt60=2;
                    	    }
                    	    else {
                    	        if (state.backtracking>0) {state.failed=true; return ;}
                    	        NoViableAltException nvae =
                    	            new NoViableAltException("", 60, 0, input);

                    	        dbg.recognitionException(nvae);
                    	        throw nvae;
                    	    }
                    	    } finally {dbg.exitDecision(60);}

                    	    switch (alt60) {
                    	        case 1 :
                    	            dbg.enterAlt(1);

                    	            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:149:69: exp
                    	            {
                    	            dbg.location(149,69);
                    	            pushFollow(FOLLOW_exp_in_inst1280);
                    	            exp();

                    	            state._fsp--;
                    	            if (state.failed) return ;

                    	            }
                    	            break;
                    	        case 2 :
                    	            dbg.enterAlt(2);

                    	            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:149:75: '[' exp ( ',' exp )* ']'
                    	            {
                    	            dbg.location(149,75);
                    	            match(input,54,FOLLOW_54_in_inst1284); if (state.failed) return ;
                    	            dbg.location(149,79);
                    	            pushFollow(FOLLOW_exp_in_inst1286);
                    	            exp();

                    	            state._fsp--;
                    	            if (state.failed) return ;
                    	            dbg.location(149,84);
                    	            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:149:84: ( ',' exp )*
                    	            try { dbg.enterSubRule(59);

                    	            loop59:
                    	            do {
                    	                int alt59=2;
                    	                try { dbg.enterDecision(59);

                    	                int LA59_0 = input.LA(1);

                    	                if ( (LA59_0==34) ) {
                    	                    alt59=1;
                    	                }


                    	                } finally {dbg.exitDecision(59);}

                    	                switch (alt59) {
                    	            	case 1 :
                    	            	    dbg.enterAlt(1);

                    	            	    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:149:85: ',' exp
                    	            	    {
                    	            	    dbg.location(149,85);
                    	            	    match(input,34,FOLLOW_34_in_inst1290); if (state.failed) return ;
                    	            	    dbg.location(149,89);
                    	            	    pushFollow(FOLLOW_exp_in_inst1292);
                    	            	    exp();

                    	            	    state._fsp--;
                    	            	    if (state.failed) return ;

                    	            	    }
                    	            	    break;

                    	            	default :
                    	            	    break loop59;
                    	                }
                    	            } while (true);
                    	            } finally {dbg.exitSubRule(59);}

                    	            dbg.location(149,96);
                    	            match(input,55,FOLLOW_55_in_inst1297); if (state.failed) return ;

                    	            }
                    	            break;

                    	    }
                    	    } finally {dbg.exitSubRule(60);}


                    	    }
                    	    break;

                    	default :
                    	    break loop61;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(61);}

                    dbg.location(149,104);
                    match(input,55,FOLLOW_55_in_inst1303); if (state.failed) return ;
                    dbg.location(149,108);
                    match(input,24,FOLLOW_24_in_inst1305); if (state.failed) return ;

                    }
                    break;
                case 14 :
                    dbg.enterAlt(14);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:150:3: Proc30 '(' exp ',' exp ',' exp ')'
                    {
                    dbg.location(150,3);
                    match(input,Proc30,FOLLOW_Proc30_in_inst1315); if (state.failed) return ;
                    dbg.location(150,10);
                    match(input,23,FOLLOW_23_in_inst1317); if (state.failed) return ;
                    dbg.location(150,14);
                    pushFollow(FOLLOW_exp_in_inst1319);
                    exp();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(150,18);
                    match(input,34,FOLLOW_34_in_inst1321); if (state.failed) return ;
                    dbg.location(150,22);
                    pushFollow(FOLLOW_exp_in_inst1323);
                    exp();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(150,26);
                    match(input,34,FOLLOW_34_in_inst1325); if (state.failed) return ;
                    dbg.location(150,30);
                    pushFollow(FOLLOW_exp_in_inst1327);
                    exp();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(150,34);
                    match(input,24,FOLLOW_24_in_inst1329); if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        dbg.location(150, 37);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "inst");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "inst"


    // $ANTLR start "exp"
    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:167:1: exp : exps ( Opr exps )? ;
    public final void exp() throws RecognitionException {
        try { dbg.enterRule(getGrammarFileName(), "exp");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(167, 1);

        try {
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:168:3: ( exps ( Opr exps )? )
            dbg.enterAlt(1);

            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:168:5: exps ( Opr exps )?
            {
            dbg.location(168,5);
            pushFollow(FOLLOW_exps_in_exp1537);
            exps();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(168,10);
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:168:10: ( Opr exps )?
            int alt63=2;
            try { dbg.enterSubRule(63);
            try { dbg.enterDecision(63);

            int LA63_0 = input.LA(1);

            if ( (LA63_0==Opr) ) {
                alt63=1;
            }
            } finally {dbg.exitDecision(63);}

            switch (alt63) {
                case 1 :
                    dbg.enterAlt(1);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:168:12: Opr exps
                    {
                    dbg.location(168,12);
                    match(input,Opr,FOLLOW_Opr_in_exp1541); if (state.failed) return ;
                    dbg.location(168,16);
                    pushFollow(FOLLOW_exps_in_exp1543);
                    exps();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(63);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        dbg.location(168, 22);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "exp");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "exp"


    // $ANTLR start "exps"
    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:170:1: exps : ( ( '+' | '-' ) terme ( ( '+' | '-' | 'or' ) terme )* | terme ( ( '+' | '-' | 'or' ) terme )* );
    public final void exps() throws RecognitionException {
        try { dbg.enterRule(getGrammarFileName(), "exps");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(170, 1);

        try {
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:171:3: ( ( '+' | '-' ) terme ( ( '+' | '-' | 'or' ) terme )* | terme ( ( '+' | '-' | 'or' ) terme )* )
            int alt66=2;
            try { dbg.enterDecision(66);

            int LA66_0 = input.LA(1);

            if ( ((LA66_0>=56 && LA66_0<=57)) ) {
                alt66=1;
            }
            else if ( (LA66_0==ID||LA66_0==CSTE||LA66_0==23||LA66_0==25||(LA66_0>=59 && LA66_0<=62)) ) {
                alt66=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 66, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(66);}

            switch (alt66) {
                case 1 :
                    dbg.enterAlt(1);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:171:5: ( '+' | '-' ) terme ( ( '+' | '-' | 'or' ) terme )*
                    {
                    dbg.location(171,5);
                    if ( (input.LA(1)>=56 && input.LA(1)<=57) ) {
                        input.consume();
                        state.errorRecovery=false;state.failed=false;
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return ;}
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        dbg.recognitionException(mse);
                        throw mse;
                    }

                    dbg.location(171,17);
                    pushFollow(FOLLOW_terme_in_exps1566);
                    terme();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(171,23);
                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:171:23: ( ( '+' | '-' | 'or' ) terme )*
                    try { dbg.enterSubRule(64);

                    loop64:
                    do {
                        int alt64=2;
                        try { dbg.enterDecision(64);

                        try {
                            isCyclicDecision = true;
                            alt64 = dfa64.predict(input);
                        }
                        catch (NoViableAltException nvae) {
                            dbg.recognitionException(nvae);
                            throw nvae;
                        }
                        } finally {dbg.exitDecision(64);}

                        switch (alt64) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:171:25: ( '+' | '-' | 'or' ) terme
                    	    {
                    	    dbg.location(171,25);
                    	    if ( (input.LA(1)>=56 && input.LA(1)<=58) ) {
                    	        input.consume();
                    	        state.errorRecovery=false;state.failed=false;
                    	    }
                    	    else {
                    	        if (state.backtracking>0) {state.failed=true; return ;}
                    	        MismatchedSetException mse = new MismatchedSetException(null,input);
                    	        dbg.recognitionException(mse);
                    	        throw mse;
                    	    }

                    	    dbg.location(171,44);
                    	    pushFollow(FOLLOW_terme_in_exps1582);
                    	    terme();

                    	    state._fsp--;
                    	    if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop64;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(64);}


                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:171:57: terme ( ( '+' | '-' | 'or' ) terme )*
                    {
                    dbg.location(171,57);
                    pushFollow(FOLLOW_terme_in_exps1591);
                    terme();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(171,63);
                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:171:63: ( ( '+' | '-' | 'or' ) terme )*
                    try { dbg.enterSubRule(65);

                    loop65:
                    do {
                        int alt65=2;
                        try { dbg.enterDecision(65);

                        try {
                            isCyclicDecision = true;
                            alt65 = dfa65.predict(input);
                        }
                        catch (NoViableAltException nvae) {
                            dbg.recognitionException(nvae);
                            throw nvae;
                        }
                        } finally {dbg.exitDecision(65);}

                        switch (alt65) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:171:65: ( '+' | '-' | 'or' ) terme
                    	    {
                    	    dbg.location(171,65);
                    	    if ( (input.LA(1)>=56 && input.LA(1)<=58) ) {
                    	        input.consume();
                    	        state.errorRecovery=false;state.failed=false;
                    	    }
                    	    else {
                    	        if (state.backtracking>0) {state.failed=true; return ;}
                    	        MismatchedSetException mse = new MismatchedSetException(null,input);
                    	        dbg.recognitionException(mse);
                    	        throw mse;
                    	    }

                    	    dbg.location(171,84);
                    	    pushFollow(FOLLOW_terme_in_exps1607);
                    	    terme();

                    	    state._fsp--;
                    	    if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop65;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(65);}


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        dbg.location(171, 92);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "exps");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "exps"


    // $ANTLR start "terme"
    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:173:1: terme : facteur ( Opm facteur )* ;
    public final void terme() throws RecognitionException {
        try { dbg.enterRule(getGrammarFileName(), "terme");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(173, 1);

        try {
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:174:3: ( facteur ( Opm facteur )* )
            dbg.enterAlt(1);

            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:174:5: facteur ( Opm facteur )*
            {
            dbg.location(174,5);
            pushFollow(FOLLOW_facteur_in_terme1621);
            facteur();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(174,12);
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:174:12: ( Opm facteur )*
            try { dbg.enterSubRule(67);

            loop67:
            do {
                int alt67=2;
                try { dbg.enterDecision(67);

                int LA67_0 = input.LA(1);

                if ( (LA67_0==Opm) ) {
                    alt67=1;
                }


                } finally {dbg.exitDecision(67);}

                switch (alt67) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:174:13: Opm facteur
            	    {
            	    dbg.location(174,13);
            	    match(input,Opm,FOLLOW_Opm_in_terme1623); if (state.failed) return ;
            	    dbg.location(174,17);
            	    pushFollow(FOLLOW_facteur_in_terme1625);
            	    facteur();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop67;
                }
            } while (true);
            } finally {dbg.exitSubRule(67);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        dbg.location(174, 26);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "terme");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "terme"


    // $ANTLR start "facteur"
    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:176:1: facteur : ( ID | CSTE | fonct | 'nil' | '(' exp ')' | 'not' facteur | ( 'true' | 'false' ) );
    public final void facteur() throws RecognitionException {
        try { dbg.enterRule(getGrammarFileName(), "facteur");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(176, 1);

        try {
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:177:3: ( ID | CSTE | fonct | 'nil' | '(' exp ')' | 'not' facteur | ( 'true' | 'false' ) )
            int alt68=7;
            try { dbg.enterDecision(68);

            switch ( input.LA(1) ) {
            case ID:
                {
                alt68=1;
                }
                break;
            case CSTE:
                {
                alt68=2;
                }
                break;
            case 25:
                {
                alt68=3;
                }
                break;
            case 59:
                {
                alt68=4;
                }
                break;
            case 23:
                {
                alt68=5;
                }
                break;
            case 60:
                {
                alt68=6;
                }
                break;
            case 61:
            case 62:
                {
                alt68=7;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 68, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }

            } finally {dbg.exitDecision(68);}

            switch (alt68) {
                case 1 :
                    dbg.enterAlt(1);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:177:5: ID
                    {
                    dbg.location(177,5);
                    match(input,ID,FOLLOW_ID_in_facteur1642); if (state.failed) return ;

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:177:11: CSTE
                    {
                    dbg.location(177,11);
                    match(input,CSTE,FOLLOW_CSTE_in_facteur1647); if (state.failed) return ;

                    }
                    break;
                case 3 :
                    dbg.enterAlt(3);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:177:18: fonct
                    {
                    dbg.location(177,18);
                    pushFollow(FOLLOW_fonct_in_facteur1651);
                    fonct();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 4 :
                    dbg.enterAlt(4);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:177:26: 'nil'
                    {
                    dbg.location(177,26);
                    match(input,59,FOLLOW_59_in_facteur1655); if (state.failed) return ;

                    }
                    break;
                case 5 :
                    dbg.enterAlt(5);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:177:34: '(' exp ')'
                    {
                    dbg.location(177,34);
                    match(input,23,FOLLOW_23_in_facteur1659); if (state.failed) return ;
                    dbg.location(177,38);
                    pushFollow(FOLLOW_exp_in_facteur1661);
                    exp();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(177,42);
                    match(input,24,FOLLOW_24_in_facteur1663); if (state.failed) return ;

                    }
                    break;
                case 6 :
                    dbg.enterAlt(6);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:177:48: 'not' facteur
                    {
                    dbg.location(177,48);
                    match(input,60,FOLLOW_60_in_facteur1667); if (state.failed) return ;
                    dbg.location(177,54);
                    pushFollow(FOLLOW_facteur_in_facteur1669);
                    facteur();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 7 :
                    dbg.enterAlt(7);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:177:64: ( 'true' | 'false' )
                    {
                    dbg.location(177,64);
                    if ( (input.LA(1)>=61 && input.LA(1)<=62) ) {
                        input.consume();
                        state.errorRecovery=false;state.failed=false;
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return ;}
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        dbg.recognitionException(mse);
                        throw mse;
                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        dbg.location(177, 82);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "facteur");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "facteur"


    // $ANTLR start "fanct"
    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:179:1: fanct : ( fonct27 '(' fonct ')' | fonct57 '(' ID ')' | fonct32 '(' fonct ',' exp ')' | fonct34 '(' exp ',' exp ')' | fonct58 ID | 'item' '(' fonct ( exp ( ',' exp )* )? ')' );
    public final void fanct() throws RecognitionException {
        try { dbg.enterRule(getGrammarFileName(), "fanct");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(179, 1);

        try {
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:180:3: ( fonct27 '(' fonct ')' | fonct57 '(' ID ')' | fonct32 '(' fonct ',' exp ')' | fonct34 '(' exp ',' exp ')' | fonct58 ID | 'item' '(' fonct ( exp ( ',' exp )* )? ')' )
            int alt71=6;
            try { dbg.enterDecision(71);

            switch ( input.LA(1) ) {
            case 75:
            case 76:
                {
                int LA71_1 = input.LA(2);

                if ( (LA71_1==ID) ) {
                    alt71=5;
                }
                else if ( (LA71_1==23) ) {
                    alt71=1;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 71, 1, input);

                    dbg.recognitionException(nvae);
                    throw nvae;
                }
                }
                break;
            case 77:
            case 78:
                {
                alt71=2;
                }
                break;
            case 79:
            case 80:
                {
                alt71=3;
                }
                break;
            case 33:
            case 81:
            case 82:
            case 83:
            case 84:
            case 85:
            case 86:
                {
                alt71=4;
                }
                break;
            case 64:
            case 65:
            case 66:
            case 67:
            case 68:
            case 69:
            case 70:
            case 71:
            case 72:
            case 73:
            case 74:
                {
                alt71=1;
                }
                break;
            case 63:
                {
                alt71=6;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 71, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }

            } finally {dbg.exitDecision(71);}

            switch (alt71) {
                case 1 :
                    dbg.enterAlt(1);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:180:5: fonct27 '(' fonct ')'
                    {
                    dbg.location(180,5);
                    pushFollow(FOLLOW_fonct27_in_fanct1693);
                    fonct27();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(180,14);
                    match(input,23,FOLLOW_23_in_fanct1696); if (state.failed) return ;
                    dbg.location(180,18);
                    pushFollow(FOLLOW_fonct_in_fanct1698);
                    fonct();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(180,24);
                    match(input,24,FOLLOW_24_in_fanct1700); if (state.failed) return ;

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:181:3: fonct57 '(' ID ')'
                    {
                    dbg.location(181,3);
                    pushFollow(FOLLOW_fonct57_in_fanct1707);
                    fonct57();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(181,12);
                    match(input,23,FOLLOW_23_in_fanct1710); if (state.failed) return ;
                    dbg.location(181,16);
                    match(input,ID,FOLLOW_ID_in_fanct1712); if (state.failed) return ;
                    dbg.location(181,19);
                    match(input,24,FOLLOW_24_in_fanct1714); if (state.failed) return ;

                    }
                    break;
                case 3 :
                    dbg.enterAlt(3);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:182:3: fonct32 '(' fonct ',' exp ')'
                    {
                    dbg.location(182,3);
                    pushFollow(FOLLOW_fonct32_in_fanct1720);
                    fonct32();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(182,12);
                    match(input,23,FOLLOW_23_in_fanct1723); if (state.failed) return ;
                    dbg.location(182,16);
                    pushFollow(FOLLOW_fonct_in_fanct1725);
                    fonct();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(182,23);
                    match(input,34,FOLLOW_34_in_fanct1728); if (state.failed) return ;
                    dbg.location(182,27);
                    pushFollow(FOLLOW_exp_in_fanct1730);
                    exp();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(182,31);
                    match(input,24,FOLLOW_24_in_fanct1732); if (state.failed) return ;

                    }
                    break;
                case 4 :
                    dbg.enterAlt(4);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:183:3: fonct34 '(' exp ',' exp ')'
                    {
                    dbg.location(183,3);
                    pushFollow(FOLLOW_fonct34_in_fanct1750);
                    fonct34();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(183,11);
                    match(input,23,FOLLOW_23_in_fanct1752); if (state.failed) return ;
                    dbg.location(183,15);
                    pushFollow(FOLLOW_exp_in_fanct1754);
                    exp();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(183,19);
                    match(input,34,FOLLOW_34_in_fanct1756); if (state.failed) return ;
                    dbg.location(183,23);
                    pushFollow(FOLLOW_exp_in_fanct1758);
                    exp();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(183,27);
                    match(input,24,FOLLOW_24_in_fanct1760); if (state.failed) return ;

                    }
                    break;
                case 5 :
                    dbg.enterAlt(5);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:184:3: fonct58 ID
                    {
                    dbg.location(184,3);
                    pushFollow(FOLLOW_fonct58_in_fanct1766);
                    fonct58();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(184,11);
                    match(input,ID,FOLLOW_ID_in_fanct1768); if (state.failed) return ;

                    }
                    break;
                case 6 :
                    dbg.enterAlt(6);

                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:185:3: 'item' '(' fonct ( exp ( ',' exp )* )? ')'
                    {
                    dbg.location(185,3);
                    match(input,63,FOLLOW_63_in_fanct1774); if (state.failed) return ;
                    dbg.location(185,11);
                    match(input,23,FOLLOW_23_in_fanct1777); if (state.failed) return ;
                    dbg.location(185,15);
                    pushFollow(FOLLOW_fonct_in_fanct1779);
                    fonct();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(185,21);
                    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:185:21: ( exp ( ',' exp )* )?
                    int alt70=2;
                    try { dbg.enterSubRule(70);
                    try { dbg.enterDecision(70);

                    int LA70_0 = input.LA(1);

                    if ( (LA70_0==ID||LA70_0==CSTE||LA70_0==23||LA70_0==25||(LA70_0>=56 && LA70_0<=57)||(LA70_0>=59 && LA70_0<=62)) ) {
                        alt70=1;
                    }
                    } finally {dbg.exitDecision(70);}

                    switch (alt70) {
                        case 1 :
                            dbg.enterAlt(1);

                            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:185:23: exp ( ',' exp )*
                            {
                            dbg.location(185,23);
                            pushFollow(FOLLOW_exp_in_fanct1783);
                            exp();

                            state._fsp--;
                            if (state.failed) return ;
                            dbg.location(185,27);
                            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:185:27: ( ',' exp )*
                            try { dbg.enterSubRule(69);

                            loop69:
                            do {
                                int alt69=2;
                                try { dbg.enterDecision(69);

                                int LA69_0 = input.LA(1);

                                if ( (LA69_0==34) ) {
                                    alt69=1;
                                }


                                } finally {dbg.exitDecision(69);}

                                switch (alt69) {
                            	case 1 :
                            	    dbg.enterAlt(1);

                            	    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:185:28: ',' exp
                            	    {
                            	    dbg.location(185,28);
                            	    match(input,34,FOLLOW_34_in_fanct1786); if (state.failed) return ;
                            	    dbg.location(185,32);
                            	    pushFollow(FOLLOW_exp_in_fanct1788);
                            	    exp();

                            	    state._fsp--;
                            	    if (state.failed) return ;

                            	    }
                            	    break;

                            	default :
                            	    break loop69;
                                }
                            } while (true);
                            } finally {dbg.exitSubRule(69);}


                            }
                            break;

                    }
                    } finally {dbg.exitSubRule(70);}

                    dbg.location(185,42);
                    match(input,24,FOLLOW_24_in_fanct1796); if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        dbg.location(185, 45);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "fanct");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "fanct"


    // $ANTLR start "fonct27"
    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:187:1: fonct27 : ( 'left_son' | 'rigth_son' | 'father' | 'info' | 'value' | 'next' | 'previous' | 'queue_empty' | 'stack_empty' | 'degree' | 'length' | 'alea_string' | 'alea_number' );
    public final void fonct27() throws RecognitionException {
        try { dbg.enterRule(getGrammarFileName(), "fonct27");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(187, 1);

        try {
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:188:3: ( 'left_son' | 'rigth_son' | 'father' | 'info' | 'value' | 'next' | 'previous' | 'queue_empty' | 'stack_empty' | 'degree' | 'length' | 'alea_string' | 'alea_number' )
            dbg.enterAlt(1);

            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:
            {
            dbg.location(188,3);
            if ( (input.LA(1)>=64 && input.LA(1)<=76) ) {
                input.consume();
                state.errorRecovery=false;state.failed=false;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                MismatchedSetException mse = new MismatchedSetException(null,input);
                dbg.recognitionException(mse);
                throw mse;
            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        dbg.location(188, 167);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "fonct27");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "fonct27"


    // $ANTLR start "fonct57"
    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:190:1: fonct57 : ( 'alloc_bloc' | 'end_file' );
    public final void fonct57() throws RecognitionException {
        try { dbg.enterRule(getGrammarFileName(), "fonct57");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(190, 1);

        try {
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:191:3: ( 'alloc_bloc' | 'end_file' )
            dbg.enterAlt(1);

            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:
            {
            dbg.location(191,3);
            if ( (input.LA(1)>=77 && input.LA(1)<=78) ) {
                input.consume();
                state.errorRecovery=false;state.failed=false;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                MismatchedSetException mse = new MismatchedSetException(null,input);
                dbg.recognitionException(mse);
                throw mse;
            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        dbg.location(191, 30);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "fonct57");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "fonct57"


    // $ANTLR start "fonct32"
    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:193:1: fonct32 : ( 'son' | 'infor' );
    public final void fonct32() throws RecognitionException {
        try { dbg.enterRule(getGrammarFileName(), "fonct32");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(193, 1);

        try {
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:194:3: ( 'son' | 'infor' )
            dbg.enterAlt(1);

            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:
            {
            dbg.location(194,3);
            if ( (input.LA(1)>=79 && input.LA(1)<=80) ) {
                input.consume();
                state.errorRecovery=false;state.failed=false;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                MismatchedSetException mse = new MismatchedSetException(null,input);
                dbg.recognitionException(mse);
                throw mse;
            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        dbg.location(194, 20);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "fonct32");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "fonct32"


    // $ANTLR start "fonct34"
    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:196:1: fonct34 : ( 'mod' | 'min' | 'max' | 'struct' | 'charact' | 'header' | 'exp' );
    public final void fonct34() throws RecognitionException {
        try { dbg.enterRule(getGrammarFileName(), "fonct34");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(196, 1);

        try {
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:197:3: ( 'mod' | 'min' | 'max' | 'struct' | 'charact' | 'header' | 'exp' )
            dbg.enterAlt(1);

            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:
            {
            dbg.location(197,3);
            if ( input.LA(1)==33||(input.LA(1)>=81 && input.LA(1)<=86) ) {
                input.consume();
                state.errorRecovery=false;state.failed=false;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                MismatchedSetException mse = new MismatchedSetException(null,input);
                dbg.recognitionException(mse);
                throw mse;
            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        dbg.location(197, 66);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "fonct34");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "fonct34"


    // $ANTLR start "fonct58"
    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:199:1: fonct58 : ( 'alea_string' | 'alea_number' );
    public final void fonct58() throws RecognitionException {
        try { dbg.enterRule(getGrammarFileName(), "fonct58");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(199, 1);

        try {
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:200:3: ( 'alea_string' | 'alea_number' )
            dbg.enterAlt(1);

            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:
            {
            dbg.location(200,3);
            if ( (input.LA(1)>=75 && input.LA(1)<=76) ) {
                input.consume();
                state.errorRecovery=false;state.failed=false;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                MismatchedSetException mse = new MismatchedSetException(null,input);
                dbg.recognitionException(mse);
                throw mse;
            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        dbg.location(200, 34);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "fonct58");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "fonct58"

    public static class definition_return extends ParserRuleReturnScope {
    };

    // $ANTLR start "definition"
    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:215:1: definition : ( 'definition' | 'definitions' );
    public final GrammaireZ2EnuParser.definition_return definition() throws RecognitionException {
        GrammaireZ2EnuParser.definition_return retval = new GrammaireZ2EnuParser.definition_return();
        retval.start = input.LT(1);

        try { dbg.enterRule(getGrammarFileName(), "definition");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(215, 1);

        try {
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:216:2: ( 'definition' | 'definitions' )
            dbg.enterAlt(1);

            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:
            {
            dbg.location(216,2);
            if ( (input.LA(1)>=87 && input.LA(1)<=88) ) {
                input.consume();
                state.errorRecovery=false;state.failed=false;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                MismatchedSetException mse = new MismatchedSetException(null,input);
                dbg.recognitionException(mse);
                throw mse;
            }


            }

            retval.stop = input.LT(-1);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        dbg.location(216, 30);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "definition");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return retval;
    }
    // $ANTLR end "definition"


    // $ANTLR start "lisIngnore"
    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:218:1: lisIngnore : (~ ( 'end' ) )* ;
    public final void lisIngnore() throws RecognitionException {
        try { dbg.enterRule(getGrammarFileName(), "lisIngnore");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(218, 1);

        try {
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:219:2: ( (~ ( 'end' ) )* )
            dbg.enterAlt(1);

            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:219:4: (~ ( 'end' ) )*
            {
            dbg.location(219,4);
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:219:4: (~ ( 'end' ) )*
            try { dbg.enterSubRule(72);

            loop72:
            do {
                int alt72=2;
                try { dbg.enterDecision(72);

                int LA72_0 = input.LA(1);

                if ( ((LA72_0>=ID && LA72_0<=19)||(LA72_0>=21 && LA72_0<=88)) ) {
                    alt72=1;
                }


                } finally {dbg.exitDecision(72);}

                switch (alt72) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:219:5: ~ ( 'end' )
            	    {
            	    dbg.location(219,5);
            	    if ( (input.LA(1)>=ID && input.LA(1)<=19)||(input.LA(1)>=21 && input.LA(1)<=88) ) {
            	        input.consume();
            	        state.errorRecovery=false;state.failed=false;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return ;}
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        dbg.recognitionException(mse);
            	        throw mse;
            	    }


            	    }
            	    break;

            	default :
            	    break loop72;
                }
            } while (true);
            } finally {dbg.exitSubRule(72);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        dbg.location(219, 15);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "lisIngnore");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "lisIngnore"


    // $ANTLR start "lisIngnorebeing"
    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:221:1: lisIngnorebeing : (~ ( 'begin' ) )* ;
    public final void lisIngnorebeing() throws RecognitionException {
        try { dbg.enterRule(getGrammarFileName(), "lisIngnorebeing");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(221, 1);

        try {
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:222:2: ( (~ ( 'begin' ) )* )
            dbg.enterAlt(1);

            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:222:4: (~ ( 'begin' ) )*
            {
            dbg.location(222,4);
            // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:222:4: (~ ( 'begin' ) )*
            try { dbg.enterSubRule(73);

            loop73:
            do {
                int alt73=2;
                try { dbg.enterDecision(73);

                int LA73_0 = input.LA(1);

                if ( (LA73_0==21) ) {
                    int LA73_1 = input.LA(2);

                    if ( (synpred130_GrammaireZ2Enu()) ) {
                        alt73=1;
                    }


                }
                else if ( ((LA73_0>=ID && LA73_0<=COMMENT)||LA73_0==20||(LA73_0>=22 && LA73_0<=88)) ) {
                    alt73=1;
                }


                } finally {dbg.exitDecision(73);}

                switch (alt73) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:222:5: ~ ( 'begin' )
            	    {
            	    dbg.location(222,5);
            	    if ( (input.LA(1)>=ID && input.LA(1)<=COMMENT)||(input.LA(1)>=20 && input.LA(1)<=88) ) {
            	        input.consume();
            	        state.errorRecovery=false;state.failed=false;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return ;}
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        dbg.recognitionException(mse);
            	        throw mse;
            	    }


            	    }
            	    break;

            	default :
            	    break loop73;
                }
            } while (true);
            } finally {dbg.exitSubRule(73);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        dbg.location(222, 17);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "lisIngnorebeing");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "lisIngnorebeing"

    // $ANTLR start synpred1_GrammaireZ2Enu
    public final void synpred1_GrammaireZ2Enu_fragment() throws RecognitionException {   
        GrammaireZ2EnuParser.definition_return st = null;


        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:30:7: (st= definition )
        dbg.enterAlt(1);

        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:30:7: st= definition
        {
        dbg.location(30,7);
        pushFollow(FOLLOW_definition_in_synpred1_GrammaireZ2Enu81);
        st=definition();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred1_GrammaireZ2Enu

    // $ANTLR start synpred3_GrammaireZ2Enu
    public final void synpred3_GrammaireZ2Enu_fragment() throws RecognitionException {   
        GrammaireZ2EnuParser.definition_return st = null;

        List<VariableDeclare> p = null;


        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:30:5: ( (st= definition )? (p= ps )? )
        dbg.enterAlt(1);

        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:30:5: (st= definition )? (p= ps )?
        {
        dbg.location(30,7);
        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:30:7: (st= definition )?
        int alt74=2;
        try { dbg.enterSubRule(74);
        try { dbg.enterDecision(74);

        int LA74_0 = input.LA(1);

        if ( ((LA74_0>=87 && LA74_0<=88)) ) {
            int LA74_1 = input.LA(2);

            if ( (synpred1_GrammaireZ2Enu()) ) {
                alt74=1;
            }
        }
        } finally {dbg.exitDecision(74);}

        switch (alt74) {
            case 1 :
                dbg.enterAlt(1);

                // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:0:0: st= definition
                {
                dbg.location(30,7);
                pushFollow(FOLLOW_definition_in_synpred3_GrammaireZ2Enu81);
                st=definition();

                state._fsp--;
                if (state.failed) return ;

                }
                break;

        }
        } finally {dbg.exitSubRule(74);}

        dbg.location(30,22);
        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:30:22: (p= ps )?
        int alt75=2;
        try { dbg.enterSubRule(75);
        try { dbg.enterDecision(75);

        int LA75_0 = input.LA(1);

        if ( ((LA75_0>=ID && LA75_0<=COMMENT)||(LA75_0>=20 && LA75_0<=88)) ) {
            alt75=1;
        }
        } finally {dbg.exitDecision(75);}

        switch (alt75) {
            case 1 :
                dbg.enterAlt(1);

                // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:0:0: p= ps
                {
                dbg.location(30,22);
                pushFollow(FOLLOW_ps_in_synpred3_GrammaireZ2Enu87);
                p=ps();

                state._fsp--;
                if (state.failed) return ;

                }
                break;

        }
        } finally {dbg.exitSubRule(75);}


        }
    }
    // $ANTLR end synpred3_GrammaireZ2Enu

    // $ANTLR start synpred8_GrammaireZ2Enu
    public final void synpred8_GrammaireZ2Enu_fragment() throws RecognitionException {   
        Token id=null;

        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:47:17: (id= ID )
        dbg.enterAlt(1);

        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:47:17: id= ID
        {
        dbg.location(47,17);
        id=(Token)match(input,ID,FOLLOW_ID_in_synpred8_GrammaireZ2Enu170); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred8_GrammaireZ2Enu

    // $ANTLR start synpred10_GrammaireZ2Enu
    public final void synpred10_GrammaireZ2Enu_fragment() throws RecognitionException {   
        List<VariableDeclare> i = null;


        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:47:25: ( '(' (i= li )? ')' )
        dbg.enterAlt(1);

        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:47:25: '(' (i= li )? ')'
        {
        dbg.location(47,25);
        match(input,23,FOLLOW_23_in_synpred10_GrammaireZ2Enu176); if (state.failed) return ;
        dbg.location(47,30);
        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:47:30: (i= li )?
        int alt78=2;
        try { dbg.enterSubRule(78);
        try { dbg.enterDecision(78);

        int LA78_0 = input.LA(1);

        if ( (LA78_0==ID) ) {
            alt78=1;
        }
        } finally {dbg.exitDecision(78);}

        switch (alt78) {
            case 1 :
                dbg.enterAlt(1);

                // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:0:0: i= li
                {
                dbg.location(47,30);
                pushFollow(FOLLOW_li_in_synpred10_GrammaireZ2Enu180);
                i=li();

                state._fsp--;
                if (state.failed) return ;

                }
                break;

        }
        } finally {dbg.exitSubRule(78);}

        dbg.location(47,35);
        match(input,24,FOLLOW_24_in_synpred10_GrammaireZ2Enu183); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred10_GrammaireZ2Enu

    // $ANTLR start synpred11_GrammaireZ2Enu
    public final void synpred11_GrammaireZ2Enu_fragment() throws RecognitionException {   
        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:47:43: ( ';' )
        dbg.enterAlt(1);

        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:47:43: ';'
        {
        dbg.location(47,43);
        match(input,21,FOLLOW_21_in_synpred11_GrammaireZ2Enu189); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred11_GrammaireZ2Enu

    // $ANTLR start synpred12_GrammaireZ2Enu
    public final void synpred12_GrammaireZ2Enu_fragment() throws RecognitionException {   
        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:47:50: ( definition )
        dbg.enterAlt(1);

        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:47:50: definition
        {
        dbg.location(47,50);
        pushFollow(FOLLOW_definition_in_synpred12_GrammaireZ2Enu194);
        definition();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred12_GrammaireZ2Enu

    // $ANTLR start synpred14_GrammaireZ2Enu
    public final void synpred14_GrammaireZ2Enu_fragment() throws RecognitionException {   
        List<VariableDeclare> p = null;


        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:47:50: ( ( definition )? (p= ps )? )
        dbg.enterAlt(1);

        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:47:50: ( definition )? (p= ps )?
        {
        dbg.location(47,50);
        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:47:50: ( definition )?
        int alt79=2;
        try { dbg.enterSubRule(79);
        try { dbg.enterDecision(79);

        int LA79_0 = input.LA(1);

        if ( ((LA79_0>=87 && LA79_0<=88)) ) {
            int LA79_1 = input.LA(2);

            if ( (synpred12_GrammaireZ2Enu()) ) {
                alt79=1;
            }
        }
        } finally {dbg.exitDecision(79);}

        switch (alt79) {
            case 1 :
                dbg.enterAlt(1);

                // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:0:0: definition
                {
                dbg.location(47,50);
                pushFollow(FOLLOW_definition_in_synpred14_GrammaireZ2Enu194);
                definition();

                state._fsp--;
                if (state.failed) return ;

                }
                break;

        }
        } finally {dbg.exitSubRule(79);}

        dbg.location(47,63);
        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:47:63: (p= ps )?
        int alt80=2;
        try { dbg.enterSubRule(80);
        try { dbg.enterDecision(80);

        int LA80_0 = input.LA(1);

        if ( ((LA80_0>=ID && LA80_0<=COMMENT)||(LA80_0>=20 && LA80_0<=88)) ) {
            alt80=1;
        }
        } finally {dbg.exitDecision(80);}

        switch (alt80) {
            case 1 :
                dbg.enterAlt(1);

                // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:0:0: p= ps
                {
                dbg.location(47,63);
                pushFollow(FOLLOW_ps_in_synpred14_GrammaireZ2Enu199);
                p=ps();

                state._fsp--;
                if (state.failed) return ;

                }
                break;

        }
        } finally {dbg.exitSubRule(80);}


        }
    }
    // $ANTLR end synpred14_GrammaireZ2Enu

    // $ANTLR start synpred17_GrammaireZ2Enu
    public final void synpred17_GrammaireZ2Enu_fragment() throws RecognitionException {   
        GrammaireZ2EnuParser.typ_return ta = null;


        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:65:44: (ta= typ )
        dbg.enterAlt(1);

        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:65:44: ta= typ
        {
        dbg.location(65,44);
        pushFollow(FOLLOW_typ_in_synpred17_GrammaireZ2Enu262);
        ta=typ();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred17_GrammaireZ2Enu

    // $ANTLR start synpred18_GrammaireZ2Enu
    public final void synpred18_GrammaireZ2Enu_fragment() throws RecognitionException {   
        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:65:52: ( definition )
        dbg.enterAlt(1);

        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:65:52: definition
        {
        dbg.location(65,52);
        pushFollow(FOLLOW_definition_in_synpred18_GrammaireZ2Enu267);
        definition();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred18_GrammaireZ2Enu

    // $ANTLR start synpred20_GrammaireZ2Enu
    public final void synpred20_GrammaireZ2Enu_fragment() throws RecognitionException {   
        List<VariableDeclare> p = null;


        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:65:52: ( ( definition )? (p= ps )? )
        dbg.enterAlt(1);

        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:65:52: ( definition )? (p= ps )?
        {
        dbg.location(65,52);
        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:65:52: ( definition )?
        int alt81=2;
        try { dbg.enterSubRule(81);
        try { dbg.enterDecision(81);

        int LA81_0 = input.LA(1);

        if ( ((LA81_0>=87 && LA81_0<=88)) ) {
            int LA81_1 = input.LA(2);

            if ( (synpred18_GrammaireZ2Enu()) ) {
                alt81=1;
            }
        }
        } finally {dbg.exitDecision(81);}

        switch (alt81) {
            case 1 :
                dbg.enterAlt(1);

                // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:0:0: definition
                {
                dbg.location(65,52);
                pushFollow(FOLLOW_definition_in_synpred20_GrammaireZ2Enu267);
                definition();

                state._fsp--;
                if (state.failed) return ;

                }
                break;

        }
        } finally {dbg.exitSubRule(81);}

        dbg.location(65,65);
        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:65:65: (p= ps )?
        int alt82=2;
        try { dbg.enterSubRule(82);
        try { dbg.enterDecision(82);

        int LA82_0 = input.LA(1);

        if ( ((LA82_0>=ID && LA82_0<=COMMENT)||(LA82_0>=20 && LA82_0<=88)) ) {
            alt82=1;
        }
        } finally {dbg.exitDecision(82);}

        switch (alt82) {
            case 1 :
                dbg.enterAlt(1);

                // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:0:0: p= ps
                {
                dbg.location(65,65);
                pushFollow(FOLLOW_ps_in_synpred20_GrammaireZ2Enu272);
                p=ps();

                state._fsp--;
                if (state.failed) return ;

                }
                break;

        }
        } finally {dbg.exitSubRule(82);}


        }
    }
    // $ANTLR end synpred20_GrammaireZ2Enu

    // $ANTLR start synpred21_GrammaireZ2Enu
    public final void synpred21_GrammaireZ2Enu_fragment() throws RecognitionException {   
        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:84:5: ( definition )
        dbg.enterAlt(1);

        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:84:5: definition
        {
        dbg.location(84,5);
        pushFollow(FOLLOW_definition_in_synpred21_GrammaireZ2Enu371);
        definition();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred21_GrammaireZ2Enu

    // $ANTLR start synpred25_GrammaireZ2Enu
    public final void synpred25_GrammaireZ2Enu_fragment() throws RecognitionException {   
        Token a1=null;
        Token f1=null;
        GrammaireZ2EnuParser.typ_return t1 = null;

        GrammaireZ2EnuParser.typ_return t2 = null;


        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:88:4: ( ( li ( Sep ) (t1= typ | (a1= 'action' | f1= 'function' '(' t2= typ ')' ) ) ) )
        dbg.enterAlt(1);

        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:88:4: ( li ( Sep ) (t1= typ | (a1= 'action' | f1= 'function' '(' t2= typ ')' ) ) )
        {
        dbg.location(88,4);
        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:88:4: ( li ( Sep ) (t1= typ | (a1= 'action' | f1= 'function' '(' t2= typ ')' ) ) )
        dbg.enterAlt(1);

        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:88:5: li ( Sep ) (t1= typ | (a1= 'action' | f1= 'function' '(' t2= typ ')' ) )
        {
        dbg.location(88,5);
        pushFollow(FOLLOW_li_in_synpred25_GrammaireZ2Enu423);
        li();

        state._fsp--;
        if (state.failed) return ;
        dbg.location(88,8);
        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:88:8: ( Sep )
        dbg.enterAlt(1);

        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:88:9: Sep
        {
        dbg.location(88,9);
        match(input,Sep,FOLLOW_Sep_in_synpred25_GrammaireZ2Enu426); if (state.failed) return ;

        }

        dbg.location(88,14);
        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:88:14: (t1= typ | (a1= 'action' | f1= 'function' '(' t2= typ ')' ) )
        int alt85=2;
        try { dbg.enterSubRule(85);
        try { dbg.enterDecision(85);

        int LA85_0 = input.LA(1);

        if ( (LA85_0==Types||LA85_0==Autres||LA85_0==23||LA85_0==28||(LA85_0>=31 && LA85_0<=32)||(LA85_0>=36 && LA85_0<=37)) ) {
            alt85=1;
        }
        else if ( (LA85_0==22||LA85_0==25) ) {
            alt85=2;
        }
        else {
            if (state.backtracking>0) {state.failed=true; return ;}
            NoViableAltException nvae =
                new NoViableAltException("", 85, 0, input);

            dbg.recognitionException(nvae);
            throw nvae;
        }
        } finally {dbg.exitDecision(85);}

        switch (alt85) {
            case 1 :
                dbg.enterAlt(1);

                // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:88:15: t1= typ
                {
                dbg.location(88,18);
                pushFollow(FOLLOW_typ_in_synpred25_GrammaireZ2Enu434);
                t1=typ();

                state._fsp--;
                if (state.failed) return ;

                }
                break;
            case 2 :
                dbg.enterAlt(2);

                // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:88:26: (a1= 'action' | f1= 'function' '(' t2= typ ')' )
                {
                dbg.location(88,26);
                // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:88:26: (a1= 'action' | f1= 'function' '(' t2= typ ')' )
                int alt84=2;
                try { dbg.enterSubRule(84);
                try { dbg.enterDecision(84);

                int LA84_0 = input.LA(1);

                if ( (LA84_0==22) ) {
                    alt84=1;
                }
                else if ( (LA84_0==25) ) {
                    alt84=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 84, 0, input);

                    dbg.recognitionException(nvae);
                    throw nvae;
                }
                } finally {dbg.exitDecision(84);}

                switch (alt84) {
                    case 1 :
                        dbg.enterAlt(1);

                        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:88:27: a1= 'action'
                        {
                        dbg.location(88,30);
                        a1=(Token)match(input,22,FOLLOW_22_in_synpred25_GrammaireZ2Enu443); if (state.failed) return ;

                        }
                        break;
                    case 2 :
                        dbg.enterAlt(2);

                        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:88:41: f1= 'function' '(' t2= typ ')'
                        {
                        dbg.location(88,44);
                        f1=(Token)match(input,25,FOLLOW_25_in_synpred25_GrammaireZ2Enu449); if (state.failed) return ;
                        dbg.location(88,57);
                        match(input,23,FOLLOW_23_in_synpred25_GrammaireZ2Enu451); if (state.failed) return ;
                        dbg.location(88,64);
                        pushFollow(FOLLOW_typ_in_synpred25_GrammaireZ2Enu457);
                        t2=typ();

                        state._fsp--;
                        if (state.failed) return ;
                        dbg.location(88,70);
                        match(input,24,FOLLOW_24_in_synpred25_GrammaireZ2Enu459); if (state.failed) return ;

                        }
                        break;

                }
                } finally {dbg.exitSubRule(84);}


                }
                break;

        }
        } finally {dbg.exitSubRule(85);}


        }


        }
    }
    // $ANTLR end synpred25_GrammaireZ2Enu

    // $ANTLR start synpred27_GrammaireZ2Enu
    public final void synpred27_GrammaireZ2Enu_fragment() throws RecognitionException {   
        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:102:6: ( structsimple )
        dbg.enterAlt(1);

        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:102:6: structsimple
        {
        dbg.location(102,6);
        pushFollow(FOLLOW_structsimple_in_synpred27_GrammaireZ2Enu501);
        structsimple();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred27_GrammaireZ2Enu

    // $ANTLR start synpred28_GrammaireZ2Enu
    public final void synpred28_GrammaireZ2Enu_fragment() throws RecognitionException {   
        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:102:38: ( 'dynamic' )
        dbg.enterAlt(1);

        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:102:38: 'dynamic'
        {
        dbg.location(102,38);
        match(input,27,FOLLOW_27_in_synpred28_GrammaireZ2Enu509); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred28_GrammaireZ2Enu

    // $ANTLR start synpred32_GrammaireZ2Enu
    public final void synpred32_GrammaireZ2Enu_fragment() throws RecognitionException {   
        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:103:70: ( 'dynamic' )
        dbg.enterAlt(1);

        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:103:70: 'dynamic'
        {
        dbg.location(103,70);
        match(input,27,FOLLOW_27_in_synpred32_GrammaireZ2Enu541); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred32_GrammaireZ2Enu

    // $ANTLR start synpred37_GrammaireZ2Enu
    public final void synpred37_GrammaireZ2Enu_fragment() throws RecognitionException {   
        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:104:55: ( structsimple )
        dbg.enterAlt(1);

        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:104:55: structsimple
        {
        dbg.location(104,55);
        pushFollow(FOLLOW_structsimple_in_synpred37_GrammaireZ2Enu577);
        structsimple();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred37_GrammaireZ2Enu

    // $ANTLR start synpred49_GrammaireZ2Enu
    public final void synpred49_GrammaireZ2Enu_fragment() throws RecognitionException {   
        Token i2=null;

        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:131:50: ( ',' i2= ID )
        dbg.enterAlt(1);

        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:131:50: ',' i2= ID
        {
        dbg.location(131,50);
        match(input,34,FOLLOW_34_in_synpred49_GrammaireZ2Enu865); if (state.failed) return ;
        dbg.location(131,56);
        i2=(Token)match(input,ID,FOLLOW_ID_in_synpred49_GrammaireZ2Enu869); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred49_GrammaireZ2Enu

    // $ANTLR start synpred71_GrammaireZ2Enu
    public final void synpred71_GrammaireZ2Enu_fragment() throws RecognitionException {   
        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:145:30: ( ',' exp )
        dbg.enterAlt(1);

        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:145:30: ',' exp
        {
        dbg.location(145,30);
        match(input,34,FOLLOW_34_in_synpred71_GrammaireZ2Enu1148); if (state.failed) return ;
        dbg.location(145,34);
        pushFollow(FOLLOW_exp_in_synpred71_GrammaireZ2Enu1150);
        exp();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred71_GrammaireZ2Enu

    // $ANTLR start synpred87_GrammaireZ2Enu
    public final void synpred87_GrammaireZ2Enu_fragment() throws RecognitionException {   
        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:171:25: ( ( '+' | '-' | 'or' ) terme )
        dbg.enterAlt(1);

        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:171:25: ( '+' | '-' | 'or' ) terme
        {
        dbg.location(171,25);
        if ( (input.LA(1)>=56 && input.LA(1)<=58) ) {
            input.consume();
            state.errorRecovery=false;state.failed=false;
        }
        else {
            if (state.backtracking>0) {state.failed=true; return ;}
            MismatchedSetException mse = new MismatchedSetException(null,input);
            dbg.recognitionException(mse);
            throw mse;
        }

        dbg.location(171,44);
        pushFollow(FOLLOW_terme_in_synpred87_GrammaireZ2Enu1582);
        terme();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred87_GrammaireZ2Enu

    // $ANTLR start synpred91_GrammaireZ2Enu
    public final void synpred91_GrammaireZ2Enu_fragment() throws RecognitionException {   
        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:171:65: ( ( '+' | '-' | 'or' ) terme )
        dbg.enterAlt(1);

        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:171:65: ( '+' | '-' | 'or' ) terme
        {
        dbg.location(171,65);
        if ( (input.LA(1)>=56 && input.LA(1)<=58) ) {
            input.consume();
            state.errorRecovery=false;state.failed=false;
        }
        else {
            if (state.backtracking>0) {state.failed=true; return ;}
            MismatchedSetException mse = new MismatchedSetException(null,input);
            dbg.recognitionException(mse);
            throw mse;
        }

        dbg.location(171,84);
        pushFollow(FOLLOW_terme_in_synpred91_GrammaireZ2Enu1607);
        terme();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred91_GrammaireZ2Enu

    // $ANTLR start synpred130_GrammaireZ2Enu
    public final void synpred130_GrammaireZ2Enu_fragment() throws RecognitionException {   
        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:222:5: (~ ( 'begin' ) )
        dbg.enterAlt(1);

        // D:\\Nouveau dossier\\sources\\as\\EditeurSyntaxiqueVocal\\EditeurSyntaxiqueVocal\\Languages\\LanguageZ\\Grammaire\\GrammaireZ2Enu.g:222:5: ~ ( 'begin' )
        {
        dbg.location(222,5);
        if ( (input.LA(1)>=ID && input.LA(1)<=COMMENT)||(input.LA(1)>=20 && input.LA(1)<=88) ) {
            input.consume();
            state.errorRecovery=false;state.failed=false;
        }
        else {
            if (state.backtracking>0) {state.failed=true; return ;}
            MismatchedSetException mse = new MismatchedSetException(null,input);
            dbg.recognitionException(mse);
            throw mse;
        }


        }
    }
    // $ANTLR end synpred130_GrammaireZ2Enu

    // Delegated rules

    public final boolean synpred91_GrammaireZ2Enu() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred91_GrammaireZ2Enu_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred17_GrammaireZ2Enu() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred17_GrammaireZ2Enu_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred8_GrammaireZ2Enu() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred8_GrammaireZ2Enu_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred49_GrammaireZ2Enu() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred49_GrammaireZ2Enu_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred10_GrammaireZ2Enu() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred10_GrammaireZ2Enu_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred12_GrammaireZ2Enu() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred12_GrammaireZ2Enu_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred32_GrammaireZ2Enu() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred32_GrammaireZ2Enu_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred20_GrammaireZ2Enu() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred20_GrammaireZ2Enu_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred37_GrammaireZ2Enu() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred37_GrammaireZ2Enu_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred130_GrammaireZ2Enu() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred130_GrammaireZ2Enu_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred27_GrammaireZ2Enu() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred27_GrammaireZ2Enu_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred28_GrammaireZ2Enu() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred28_GrammaireZ2Enu_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred18_GrammaireZ2Enu() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred18_GrammaireZ2Enu_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred14_GrammaireZ2Enu() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred14_GrammaireZ2Enu_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred1_GrammaireZ2Enu() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred1_GrammaireZ2Enu_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred25_GrammaireZ2Enu() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred25_GrammaireZ2Enu_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred71_GrammaireZ2Enu() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred71_GrammaireZ2Enu_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred11_GrammaireZ2Enu() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred11_GrammaireZ2Enu_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred3_GrammaireZ2Enu() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred3_GrammaireZ2Enu_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred21_GrammaireZ2Enu() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred21_GrammaireZ2Enu_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred87_GrammaireZ2Enu() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred87_GrammaireZ2Enu_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }


    protected DFA10 dfa10 = new DFA10(this);
    protected DFA17 dfa17 = new DFA17(this);
    protected DFA25 dfa25 = new DFA25(this);
    protected DFA26 dfa26 = new DFA26(this);
    protected DFA32 dfa32 = new DFA32(this);
    protected DFA64 dfa64 = new DFA64(this);
    protected DFA65 dfa65 = new DFA65(this);
    static final String DFA10_eotS =
        "\10\uffff";
    static final String DFA10_eofS =
        "\10\uffff";
    static final String DFA10_minS =
        "\2\4\1\uffff\1\4\1\0\1\4\1\uffff\1\4";
    static final String DFA10_maxS =
        "\2\130\1\uffff\1\130\1\0\1\130\1\uffff\1\130";
    static final String DFA10_acceptS =
        "\2\uffff\1\2\3\uffff\1\1\1\uffff";
    static final String DFA10_specialS =
        "\4\uffff\1\0\3\uffff}>";
    static final String[] DFA10_transitionS = {
            "\23\2\1\1\101\2",
            "\1\3\16\2\1\uffff\4\2\1\4\100\2",
            "",
            "\17\2\1\uffff\4\2\1\4\11\2\1\5\66\2",
            "\1\uffff",
            "\1\7\16\2\1\uffff\105\2",
            "",
            "\17\2\1\uffff\4\2\1\4\11\2\1\5\66\2"
    };

    static final short[] DFA10_eot = DFA.unpackEncodedString(DFA10_eotS);
    static final short[] DFA10_eof = DFA.unpackEncodedString(DFA10_eofS);
    static final char[] DFA10_min = DFA.unpackEncodedStringToUnsignedChars(DFA10_minS);
    static final char[] DFA10_max = DFA.unpackEncodedStringToUnsignedChars(DFA10_maxS);
    static final short[] DFA10_accept = DFA.unpackEncodedString(DFA10_acceptS);
    static final short[] DFA10_special = DFA.unpackEncodedString(DFA10_specialS);
    static final short[][] DFA10_transition;

    static {
        int numStates = DFA10_transitionS.length;
        DFA10_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA10_transition[i] = DFA.unpackEncodedString(DFA10_transitionS[i]);
        }
    }

    class DFA10 extends DFA {

        public DFA10(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 10;
            this.eot = DFA10_eot;
            this.eof = DFA10_eof;
            this.min = DFA10_min;
            this.max = DFA10_max;
            this.accept = DFA10_accept;
            this.special = DFA10_special;
            this.transition = DFA10_transition;
        }
        public String getDescription() {
            return "47:23: ( '(' (i= li )? ')' )?";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA10_4 = input.LA(1);

                         
                        int index10_4 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred10_GrammaireZ2Enu()) ) {s = 6;}

                        else if ( (true) ) {s = 2;}

                         
                        input.seek(index10_4);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 10, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA17_eotS =
        "\121\uffff";
    static final String DFA17_eofS =
        "\121\uffff";
    static final String DFA17_minS =
        "\1\4\1\0\7\4\2\uffff\10\4\1\0\7\4\1\0\26\4\1\0\7\4\1\0\20\4\1\0"+
        "\5\4";
    static final String DFA17_maxS =
        "\1\130\1\0\7\130\2\uffff\10\130\1\0\7\130\1\0\26\130\1\0\7\130"+
        "\1\0\20\130\1\0\5\130";
    static final String DFA17_acceptS =
        "\11\uffff\1\2\1\1\106\uffff";
    static final String DFA17_specialS =
        "\1\uffff\1\3\21\uffff\1\5\7\uffff\1\1\26\uffff\1\2\7\uffff\1\0"+
        "\20\uffff\1\4\5\uffff}>";
    static final String[] DFA17_transitionS = {
            "\2\11\1\1\1\11\1\7\16\11\1\3\4\11\1\4\2\11\1\10\1\6\3\11\1"+
            "\2\1\5\63\11",
            "\1\uffff",
            "\17\11\1\uffff\3\11\1\3\101\11",
            "\2\11\1\13\14\11\1\uffff\14\11\1\14\70\11",
            "\17\11\1\uffff\11\11\1\15\73\11",
            "\3\11\1\16\13\11\1\uffff\105\11",
            "\17\11\1\uffff\3\11\1\17\101\11",
            "\17\11\1\uffff\12\11\1\20\72\11",
            "\17\11\1\uffff\12\11\1\21\72\11",
            "",
            "",
            "\17\11\1\uffff\4\11\1\23\11\11\1\22\66\11",
            "\3\11\1\24\13\11\1\uffff\105\11",
            "\4\11\1\7\12\11\1\uffff\14\11\1\6\4\11\1\5\63\11",
            "\17\11\1\uffff\12\11\1\20\72\11",
            "\3\11\1\25\13\11\1\uffff\105\11",
            "\2\11\1\33\1\11\1\30\12\11\1\uffff\3\11\1\32\10\11\1\27\3"+
            "\11\1\31\1\26\63\11",
            "\2\11\1\34\14\11\1\uffff\3\11\1\37\10\11\1\35\3\11\1\36\64"+
            "\11",
            "\2\11\1\40\14\11\1\uffff\14\11\1\41\70\11",
            "\1\uffff",
            "\17\11\1\uffff\12\11\1\42\72\11",
            "\17\11\1\uffff\4\11\1\44\11\11\1\43\66\11",
            "\3\11\1\45\13\11\1\uffff\105\11",
            "\17\11\1\uffff\3\11\1\46\101\11",
            "\17\11\1\uffff\12\11\1\20\72\11",
            "\17\11\1\uffff\3\11\1\32\101\11",
            "\2\11\1\47\14\11\1\uffff\105\11",
            "\1\uffff",
            "\17\11\1\uffff\3\11\1\51\11\11\1\50\67\11",
            "\3\11\1\52\13\11\1\uffff\105\11",
            "\17\11\1\uffff\3\11\1\37\101\11",
            "\2\11\1\53\14\11\1\uffff\14\11\1\54\70\11",
            "\17\11\1\uffff\4\11\1\23\11\11\1\22\66\11",
            "\3\11\1\55\13\11\1\uffff\105\11",
            "\2\11\1\56\14\11\1\uffff\105\11",
            "\3\11\1\57\13\11\1\uffff\105\11",
            "\17\11\1\uffff\12\11\1\20\72\11",
            "\17\11\1\uffff\12\11\1\20\72\11",
            "\3\11\1\60\13\11\1\uffff\105\11",
            "\17\11\1\uffff\4\11\1\62\11\11\1\61\66\11",
            "\17\11\1\uffff\3\11\1\51\101\11",
            "\2\11\1\63\14\11\1\uffff\105\11",
            "\17\11\1\uffff\12\11\1\64\72\11",
            "\17\11\1\uffff\4\11\1\66\11\11\1\65\66\11",
            "\3\11\1\67\13\11\1\uffff\105\11",
            "\17\11\1\uffff\12\11\1\70\72\11",
            "\17\11\1\uffff\4\11\1\72\11\11\1\71\66\11",
            "\17\11\1\uffff\4\11\1\44\11\11\1\43\66\11",
            "\17\11\1\uffff\4\11\1\74\11\11\1\73\66\11",
            "\2\11\1\75\14\11\1\uffff\105\11",
            "\1\uffff",
            "\17\11\1\uffff\4\11\1\77\11\11\1\76\66\11",
            "\2\11\1\100\14\11\1\uffff\105\11",
            "\2\11\1\101\14\11\1\uffff\14\11\1\102\70\11",
            "\17\11\1\uffff\3\11\1\51\11\11\1\50\67\11",
            "\17\11\1\uffff\12\11\1\103\72\11",
            "\2\11\1\104\14\11\1\uffff\105\11",
            "\2\11\1\105\14\11\1\uffff\14\11\1\41\70\11",
            "\1\uffff",
            "\3\11\1\106\13\11\1\uffff\105\11",
            "\17\11\1\uffff\12\11\1\20\72\11",
            "\17\11\1\uffff\4\11\1\62\11\11\1\61\66\11",
            "\2\11\1\107\14\11\1\uffff\105\11",
            "\17\11\1\uffff\17\11\1\110\65\11",
            "\17\11\1\uffff\3\11\1\51\11\11\1\50\67\11",
            "\17\11\1\uffff\4\11\1\66\11\11\1\65\66\11",
            "\3\11\1\111\13\11\1\uffff\105\11",
            "\2\11\1\112\14\11\1\uffff\105\11",
            "\17\11\1\uffff\4\11\1\72\11\11\1\71\66\11",
            "\17\11\1\uffff\4\11\1\72\11\11\1\71\66\11",
            "\17\11\1\uffff\4\11\1\74\11\11\1\73\66\11",
            "\17\11\1\uffff\4\11\1\77\11\11\1\76\66\11",
            "\1\113\16\11\1\uffff\105\11",
            "\17\11\1\uffff\12\11\1\114\72\11",
            "\17\11\1\uffff\4\11\1\116\11\11\1\115\66\11",
            "\1\uffff",
            "\2\11\1\117\14\11\1\uffff\105\11",
            "\2\11\1\120\14\11\1\uffff\14\11\1\102\70\11",
            "\17\11\1\uffff\3\11\1\51\11\11\1\50\67\11",
            "\17\11\1\uffff\4\11\1\116\11\11\1\115\66\11",
            "\17\11\1\uffff\4\11\1\116\11\11\1\115\66\11"
    };

    static final short[] DFA17_eot = DFA.unpackEncodedString(DFA17_eotS);
    static final short[] DFA17_eof = DFA.unpackEncodedString(DFA17_eofS);
    static final char[] DFA17_min = DFA.unpackEncodedStringToUnsignedChars(DFA17_minS);
    static final char[] DFA17_max = DFA.unpackEncodedStringToUnsignedChars(DFA17_maxS);
    static final short[] DFA17_accept = DFA.unpackEncodedString(DFA17_acceptS);
    static final short[] DFA17_special = DFA.unpackEncodedString(DFA17_specialS);
    static final short[][] DFA17_transition;

    static {
        int numStates = DFA17_transitionS.length;
        DFA17_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA17_transition[i] = DFA.unpackEncodedString(DFA17_transitionS[i]);
        }
    }

    class DFA17 extends DFA {

        public DFA17(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 17;
            this.eot = DFA17_eot;
            this.eof = DFA17_eof;
            this.min = DFA17_min;
            this.max = DFA17_max;
            this.accept = DFA17_accept;
            this.special = DFA17_special;
            this.transition = DFA17_transition;
        }
        public String getDescription() {
            return "65:44: (ta= typ )?";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA17_58 = input.LA(1);

                         
                        int index17_58 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred17_GrammaireZ2Enu()) ) {s = 10;}

                        else if ( (true) ) {s = 9;}

                         
                        input.seek(index17_58);
                        if ( s>=0 ) return s;
                        break;
                    case 1 : 
                        int LA17_27 = input.LA(1);

                         
                        int index17_27 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred17_GrammaireZ2Enu()) ) {s = 10;}

                        else if ( (true) ) {s = 9;}

                         
                        input.seek(index17_27);
                        if ( s>=0 ) return s;
                        break;
                    case 2 : 
                        int LA17_50 = input.LA(1);

                         
                        int index17_50 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred17_GrammaireZ2Enu()) ) {s = 10;}

                        else if ( (true) ) {s = 9;}

                         
                        input.seek(index17_50);
                        if ( s>=0 ) return s;
                        break;
                    case 3 : 
                        int LA17_1 = input.LA(1);

                         
                        int index17_1 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred17_GrammaireZ2Enu()) ) {s = 10;}

                        else if ( (true) ) {s = 9;}

                         
                        input.seek(index17_1);
                        if ( s>=0 ) return s;
                        break;
                    case 4 : 
                        int LA17_75 = input.LA(1);

                         
                        int index17_75 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred17_GrammaireZ2Enu()) ) {s = 10;}

                        else if ( (true) ) {s = 9;}

                         
                        input.seek(index17_75);
                        if ( s>=0 ) return s;
                        break;
                    case 5 : 
                        int LA17_19 = input.LA(1);

                         
                        int index17_19 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred17_GrammaireZ2Enu()) ) {s = 10;}

                        else if ( (true) ) {s = 9;}

                         
                        input.seek(index17_19);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 17, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA25_eotS =
        "\u00ab\uffff";
    static final String DFA25_eofS =
        "\u00ab\uffff";
    static final String DFA25_minS =
        "\2\4\1\uffff\3\4\1\0\7\4\1\0\1\4\1\uffff\11\4\1\0\4\4\1\0\34\4"+
        "\1\0\13\4\1\0\26\4\1\0\51\4\1\0\41\4";
    static final String DFA25_maxS =
        "\2\130\1\uffff\3\130\1\0\7\130\1\0\1\130\1\uffff\11\130\1\0\4\130"+
        "\1\0\34\130\1\0\13\130\1\0\26\130\1\0\51\130\1\0\41\130";
    static final String DFA25_acceptS =
        "\2\uffff\1\2\15\uffff\1\1\u009a\uffff";
    static final String DFA25_specialS =
        "\6\uffff\1\5\7\uffff\1\7\13\uffff\1\1\4\uffff\1\0\34\uffff\1\6"+
        "\13\uffff\1\3\26\uffff\1\4\51\uffff\1\2\41\uffff}>";
    static final String[] DFA25_transitionS = {
            "\1\1\16\2\1\uffff\105\2",
            "\1\2\1\4\15\2\1\uffff\16\2\1\3\66\2",
            "",
            "\1\5\16\2\1\uffff\105\2",
            "\2\2\1\6\1\2\1\14\12\2\1\uffff\2\2\1\16\1\10\1\2\1\17\2\2"+
            "\1\11\2\2\1\15\1\13\3\2\1\7\1\12\63\2",
            "\1\2\1\4\15\2\1\uffff\16\2\1\3\66\2",
            "\1\uffff",
            "\17\2\1\uffff\3\2\1\10\101\2",
            "\2\2\1\21\14\2\1\uffff\14\2\1\22\70\2",
            "\17\2\1\uffff\11\2\1\23\73\2",
            "\3\2\1\24\13\2\1\uffff\105\2",
            "\17\2\1\uffff\3\2\1\25\101\2",
            "\17\2\1\uffff\12\2\1\26\72\2",
            "\17\2\1\uffff\12\2\1\27\72\2",
            "\1\uffff",
            "\17\2\1\uffff\3\2\1\30\101\2",
            "",
            "\17\2\1\uffff\4\2\1\32\11\2\1\31\66\2",
            "\3\2\1\33\13\2\1\uffff\105\2",
            "\4\2\1\14\12\2\1\uffff\14\2\1\13\4\2\1\12\63\2",
            "\17\2\1\uffff\12\2\1\26\72\2",
            "\3\2\1\34\13\2\1\uffff\105\2",
            "\2\2\1\37\1\2\1\42\12\2\1\uffff\3\2\1\36\10\2\1\41\3\2\1\35"+
            "\1\40\63\2",
            "\2\2\1\43\14\2\1\uffff\3\2\1\46\10\2\1\44\3\2\1\45\64\2",
            "\2\2\1\47\1\2\1\55\12\2\1\uffff\3\2\1\51\4\2\1\52\2\2\1\56"+
            "\1\54\3\2\1\50\1\53\63\2",
            "\2\2\1\57\14\2\1\uffff\14\2\1\60\70\2",
            "\1\uffff",
            "\17\2\1\uffff\12\2\1\61\72\2",
            "\17\2\1\uffff\4\2\1\63\11\2\1\62\66\2",
            "\17\2\1\uffff\3\2\1\36\101\2",
            "\2\2\1\64\14\2\1\uffff\105\2",
            "\1\uffff",
            "\3\2\1\65\13\2\1\uffff\105\2",
            "\17\2\1\uffff\3\2\1\66\101\2",
            "\17\2\1\uffff\12\2\1\26\72\2",
            "\17\2\1\uffff\3\2\1\70\11\2\1\67\67\2",
            "\3\2\1\71\13\2\1\uffff\105\2",
            "\17\2\1\uffff\3\2\1\46\101\2",
            "\2\2\1\72\14\2\1\uffff\14\2\1\73\70\2",
            "\17\2\1\uffff\4\2\1\74\100\2",
            "\17\2\1\uffff\3\2\1\51\101\2",
            "\2\2\1\75\14\2\1\uffff\14\2\1\76\70\2",
            "\17\2\1\uffff\11\2\1\77\73\2",
            "\3\2\1\100\13\2\1\uffff\105\2",
            "\17\2\1\uffff\3\2\1\101\101\2",
            "\17\2\1\uffff\12\2\1\102\72\2",
            "\17\2\1\uffff\12\2\1\103\72\2",
            "\17\2\1\uffff\4\2\1\32\11\2\1\31\66\2",
            "\3\2\1\104\13\2\1\uffff\105\2",
            "\2\2\1\105\14\2\1\uffff\105\2",
            "\3\2\1\106\13\2\1\uffff\105\2",
            "\17\2\1\uffff\12\2\1\26\72\2",
            "\17\2\1\uffff\4\2\1\110\11\2\1\107\66\2",
            "\17\2\1\uffff\12\2\1\26\72\2",
            "\3\2\1\111\13\2\1\uffff\105\2",
            "\17\2\1\uffff\3\2\1\70\101\2",
            "\2\2\1\112\14\2\1\uffff\105\2",
            "\17\2\1\uffff\12\2\1\113\72\2",
            "\17\2\1\uffff\4\2\1\115\11\2\1\114\66\2",
            "\3\2\1\116\13\2\1\uffff\105\2",
            "\1\uffff",
            "\17\2\1\uffff\4\2\1\120\11\2\1\117\66\2",
            "\3\2\1\121\13\2\1\uffff\105\2",
            "\4\2\1\55\12\2\1\uffff\14\2\1\54\4\2\1\53\63\2",
            "\17\2\1\uffff\12\2\1\102\72\2",
            "\3\2\1\122\13\2\1\uffff\105\2",
            "\2\2\1\130\1\2\1\125\12\2\1\uffff\3\2\1\127\10\2\1\124\3\2"+
            "\1\126\1\123\63\2",
            "\2\2\1\131\14\2\1\uffff\3\2\1\134\10\2\1\132\3\2\1\133\64"+
            "\2",
            "\17\2\1\uffff\12\2\1\135\72\2",
            "\17\2\1\uffff\4\2\1\137\11\2\1\136\66\2",
            "\17\2\1\uffff\4\2\1\63\11\2\1\62\66\2",
            "\2\2\1\140\14\2\1\uffff\105\2",
            "\1\uffff",
            "\17\2\1\uffff\4\2\1\142\11\2\1\141\66\2",
            "\17\2\1\uffff\4\2\1\144\11\2\1\143\66\2",
            "\2\2\1\145\14\2\1\uffff\105\2",
            "\2\2\1\146\14\2\1\uffff\14\2\1\147\70\2",
            "\17\2\1\uffff\3\2\1\70\11\2\1\67\67\2",
            "\17\2\1\uffff\12\2\1\150\72\2",
            "\2\2\1\151\14\2\1\uffff\14\2\1\152\70\2",
            "\17\2\1\uffff\4\2\1\74\2\2\1\153\75\2",
            "\17\2\1\uffff\12\2\1\154\72\2",
            "\17\2\1\uffff\4\2\1\156\11\2\1\155\66\2",
            "\3\2\1\157\13\2\1\uffff\105\2",
            "\17\2\1\uffff\3\2\1\160\101\2",
            "\17\2\1\uffff\12\2\1\102\72\2",
            "\17\2\1\uffff\3\2\1\127\101\2",
            "\2\2\1\161\14\2\1\uffff\105\2",
            "\17\2\1\uffff\4\2\1\74\100\2",
            "\17\2\1\uffff\3\2\1\163\11\2\1\162\67\2",
            "\3\2\1\164\13\2\1\uffff\105\2",
            "\17\2\1\uffff\3\2\1\134\101\2",
            "\2\2\1\165\14\2\1\uffff\14\2\1\166\70\2",
            "\2\2\1\167\14\2\1\uffff\105\2",
            "\2\2\1\170\14\2\1\uffff\14\2\1\60\70\2",
            "\1\uffff",
            "\17\2\1\uffff\4\2\1\110\11\2\1\107\66\2",
            "\3\2\1\171\13\2\1\uffff\105\2",
            "\17\2\1\uffff\12\2\1\26\72\2",
            "\2\2\1\172\14\2\1\uffff\105\2",
            "\17\2\1\uffff\17\2\1\173\65\2",
            "\17\2\1\uffff\3\2\1\70\11\2\1\67\67\2",
            "\17\2\1\uffff\4\2\1\115\11\2\1\114\66\2",
            "\3\2\1\174\13\2\1\uffff\105\2",
            "\2\2\1\175\14\2\1\uffff\105\2",
            "\17\2\1\uffff\4\2\1\120\11\2\1\117\66\2",
            "\3\2\1\176\13\2\1\uffff\105\2",
            "\17\2\1\uffff\4\2\1\74\100\2",
            "\2\2\1\177\14\2\1\uffff\105\2",
            "\3\2\1\u0080\13\2\1\uffff\105\2",
            "\17\2\1\uffff\12\2\1\102\72\2",
            "\17\2\1\uffff\12\2\1\102\72\2",
            "\3\2\1\u0081\13\2\1\uffff\105\2",
            "\17\2\1\uffff\4\2\1\u0083\11\2\1\u0082\66\2",
            "\17\2\1\uffff\3\2\1\163\101\2",
            "\2\2\1\u0084\14\2\1\uffff\105\2",
            "\17\2\1\uffff\12\2\1\u0085\72\2",
            "\17\2\1\uffff\4\2\1\u0087\11\2\1\u0086\66\2",
            "\3\2\1\u0088\13\2\1\uffff\105\2",
            "\17\2\1\uffff\4\2\1\137\11\2\1\136\66\2",
            "\17\2\1\uffff\4\2\1\137\11\2\1\136\66\2",
            "\17\2\1\uffff\4\2\1\142\11\2\1\141\66\2",
            "\17\2\1\uffff\4\2\1\144\11\2\1\143\66\2",
            "\1\u0089\16\2\1\uffff\105\2",
            "\17\2\1\uffff\12\2\1\u008a\72\2",
            "\17\2\1\uffff\4\2\1\u008c\11\2\1\u008b\66\2",
            "\17\2\1\uffff\12\2\1\u008d\72\2",
            "\17\2\1\uffff\4\2\1\u008f\11\2\1\u008e\66\2",
            "\17\2\1\uffff\4\2\1\156\11\2\1\155\66\2",
            "\17\2\1\uffff\4\2\1\u0091\11\2\1\u0090\66\2",
            "\2\2\1\u0092\14\2\1\uffff\105\2",
            "\17\2\1\uffff\4\2\1\74\2\2\1\u0093\75\2",
            "\17\2\1\uffff\4\2\1\u0095\11\2\1\u0094\66\2",
            "\2\2\1\u0096\14\2\1\uffff\105\2",
            "\2\2\1\u0097\14\2\1\uffff\14\2\1\u0098\70\2",
            "\17\2\1\uffff\3\2\1\163\11\2\1\162\67\2",
            "\17\2\1\uffff\12\2\1\u0099\72\2",
            "\1\uffff",
            "\2\2\1\u009a\14\2\1\uffff\105\2",
            "\2\2\1\u009b\14\2\1\uffff\14\2\1\147\70\2",
            "\17\2\1\uffff\3\2\1\70\11\2\1\67\67\2",
            "\2\2\1\u009c\14\2\1\uffff\105\2",
            "\2\2\1\u009d\14\2\1\uffff\14\2\1\152\70\2",
            "\17\2\1\uffff\4\2\1\74\2\2\1\153\75\2",
            "\3\2\1\u009e\13\2\1\uffff\105\2",
            "\17\2\1\uffff\12\2\1\102\72\2",
            "\17\2\1\uffff\4\2\1\u0083\11\2\1\u0082\66\2",
            "\17\2\1\uffff\4\2\1\74\100\2",
            "\2\2\1\u009f\14\2\1\uffff\105\2",
            "\17\2\1\uffff\17\2\1\u00a0\65\2",
            "\17\2\1\uffff\3\2\1\163\11\2\1\162\67\2",
            "\17\2\1\uffff\4\2\1\u0087\11\2\1\u0086\66\2",
            "\3\2\1\u00a1\13\2\1\uffff\105\2",
            "\2\2\1\u00a2\14\2\1\uffff\105\2",
            "\17\2\1\uffff\4\2\1\u008c\11\2\1\u008b\66\2",
            "\17\2\1\uffff\4\2\1\u008c\11\2\1\u008b\66\2",
            "\17\2\1\uffff\4\2\1\u008f\11\2\1\u008e\66\2",
            "\17\2\1\uffff\4\2\1\u008f\11\2\1\u008e\66\2",
            "\17\2\1\uffff\4\2\1\u0091\11\2\1\u0090\66\2",
            "\17\2\1\uffff\4\2\1\u0095\11\2\1\u0094\66\2",
            "\1\u00a3\16\2\1\uffff\105\2",
            "\17\2\1\uffff\12\2\1\u00a4\72\2",
            "\17\2\1\uffff\4\2\1\u00a6\11\2\1\u00a5\66\2",
            "\17\2\1\uffff\4\2\1\74\11\2\1\u00a7\66\2",
            "\2\2\1\u00a8\14\2\1\uffff\105\2",
            "\2\2\1\u00a9\14\2\1\uffff\14\2\1\u0098\70\2",
            "\17\2\1\uffff\3\2\1\163\11\2\1\162\67\2",
            "\1\u00aa\16\2\1\uffff\105\2",
            "\17\2\1\uffff\4\2\1\u00a6\11\2\1\u00a5\66\2",
            "\17\2\1\uffff\4\2\1\u00a6\11\2\1\u00a5\66\2",
            "\17\2\1\uffff\4\2\1\74\11\2\1\u00a7\66\2"
    };

    static final short[] DFA25_eot = DFA.unpackEncodedString(DFA25_eotS);
    static final short[] DFA25_eof = DFA.unpackEncodedString(DFA25_eofS);
    static final char[] DFA25_min = DFA.unpackEncodedStringToUnsignedChars(DFA25_minS);
    static final char[] DFA25_max = DFA.unpackEncodedStringToUnsignedChars(DFA25_maxS);
    static final short[] DFA25_accept = DFA.unpackEncodedString(DFA25_acceptS);
    static final short[] DFA25_special = DFA.unpackEncodedString(DFA25_specialS);
    static final short[][] DFA25_transition;

    static {
        int numStates = DFA25_transitionS.length;
        DFA25_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA25_transition[i] = DFA.unpackEncodedString(DFA25_transitionS[i]);
        }
    }

    class DFA25 extends DFA {

        public DFA25(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 25;
            this.eot = DFA25_eot;
            this.eof = DFA25_eof;
            this.min = DFA25_min;
            this.max = DFA25_max;
            this.accept = DFA25_accept;
            this.special = DFA25_special;
            this.transition = DFA25_transition;
        }
        public String getDescription() {
            return "87:1: s returns [List<VariableDeclare> ids=new List<VariableDeclare>(), string type] : ( ( li ( Sep ) (t1= typ | (a1= 'action' | f1= 'function' '(' t2= typ ')' ) ) ) | lisIngnorebeing );";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA25_31 = input.LA(1);

                         
                        int index25_31 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred25_GrammaireZ2Enu()) ) {s = 16;}

                        else if ( (true) ) {s = 2;}

                         
                        input.seek(index25_31);
                        if ( s>=0 ) return s;
                        break;
                    case 1 : 
                        int LA25_26 = input.LA(1);

                         
                        int index25_26 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred25_GrammaireZ2Enu()) ) {s = 16;}

                        else if ( (true) ) {s = 2;}

                         
                        input.seek(index25_26);
                        if ( s>=0 ) return s;
                        break;
                    case 2 : 
                        int LA25_137 = input.LA(1);

                         
                        int index25_137 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred25_GrammaireZ2Enu()) ) {s = 16;}

                        else if ( (true) ) {s = 2;}

                         
                        input.seek(index25_137);
                        if ( s>=0 ) return s;
                        break;
                    case 3 : 
                        int LA25_72 = input.LA(1);

                         
                        int index25_72 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred25_GrammaireZ2Enu()) ) {s = 16;}

                        else if ( (true) ) {s = 2;}

                         
                        input.seek(index25_72);
                        if ( s>=0 ) return s;
                        break;
                    case 4 : 
                        int LA25_95 = input.LA(1);

                         
                        int index25_95 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred25_GrammaireZ2Enu()) ) {s = 16;}

                        else if ( (true) ) {s = 2;}

                         
                        input.seek(index25_95);
                        if ( s>=0 ) return s;
                        break;
                    case 5 : 
                        int LA25_6 = input.LA(1);

                         
                        int index25_6 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred25_GrammaireZ2Enu()) ) {s = 16;}

                        else if ( (true) ) {s = 2;}

                         
                        input.seek(index25_6);
                        if ( s>=0 ) return s;
                        break;
                    case 6 : 
                        int LA25_60 = input.LA(1);

                         
                        int index25_60 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred25_GrammaireZ2Enu()) ) {s = 16;}

                        else if ( (true) ) {s = 2;}

                         
                        input.seek(index25_60);
                        if ( s>=0 ) return s;
                        break;
                    case 7 : 
                        int LA25_14 = input.LA(1);

                         
                        int index25_14 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred25_GrammaireZ2Enu()) ) {s = 16;}

                        else if ( (true) ) {s = 2;}

                         
                        input.seek(index25_14);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 25, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA26_eotS =
        "\11\uffff";
    static final String DFA26_eofS =
        "\11\uffff";
    static final String DFA26_minS =
        "\2\27\1\6\1\30\1\uffff\1\6\1\0\1\30\1\uffff";
    static final String DFA26_maxS =
        "\1\44\1\27\1\40\1\42\1\uffff\1\40\1\0\1\42\1\uffff";
    static final String DFA26_acceptS =
        "\4\uffff\1\2\3\uffff\1\1";
    static final String DFA26_specialS =
        "\6\uffff\1\0\2\uffff}>";
    static final String[] DFA26_transitionS = {
            "\1\2\14\uffff\1\1",
            "\1\2",
            "\1\3\31\uffff\1\4",
            "\1\6\11\uffff\1\5",
            "",
            "\1\7\31\uffff\1\4",
            "\1\uffff",
            "\1\6\11\uffff\1\5",
            ""
    };

    static final short[] DFA26_eot = DFA.unpackEncodedString(DFA26_eotS);
    static final short[] DFA26_eof = DFA.unpackEncodedString(DFA26_eofS);
    static final char[] DFA26_min = DFA.unpackEncodedStringToUnsignedChars(DFA26_minS);
    static final char[] DFA26_max = DFA.unpackEncodedStringToUnsignedChars(DFA26_maxS);
    static final short[] DFA26_accept = DFA.unpackEncodedString(DFA26_acceptS);
    static final short[] DFA26_special = DFA.unpackEncodedString(DFA26_specialS);
    static final short[][] DFA26_transition;

    static {
        int numStates = DFA26_transitionS.length;
        DFA26_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA26_transition[i] = DFA.unpackEncodedString(DFA26_transitionS[i]);
        }
    }

    class DFA26 extends DFA {

        public DFA26(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 26;
            this.eot = DFA26_eot;
            this.eof = DFA26_eof;
            this.min = DFA26_min;
            this.max = DFA26_max;
            this.accept = DFA26_accept;
            this.special = DFA26_special;
            this.transition = DFA26_transition;
        }
        public String getDescription() {
            return "102:4: ( structsimple | strucrcomplexe )";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA26_6 = input.LA(1);

                         
                        int index26_6 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred27_GrammaireZ2Enu()) ) {s = 8;}

                        else if ( (true) ) {s = 4;}

                         
                        input.seek(index26_6);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 26, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA32_eotS =
        "\13\uffff";
    static final String DFA32_eofS =
        "\13\uffff";
    static final String DFA32_minS =
        "\1\6\2\uffff\1\27\1\6\1\30\1\uffff\1\6\1\0\1\30\1\uffff";
    static final String DFA32_maxS =
        "\1\44\2\uffff\1\27\1\40\1\42\1\uffff\1\40\1\0\1\42\1\uffff";
    static final String DFA32_acceptS =
        "\1\uffff\1\1\1\2\3\uffff\1\4\3\uffff\1\3";
    static final String DFA32_specialS =
        "\10\uffff\1\0\2\uffff}>";
    static final String[] DFA32_transitionS = {
            "\1\1\20\uffff\1\4\10\uffff\1\2\3\uffff\1\3",
            "",
            "",
            "\1\4",
            "\1\5\31\uffff\1\6",
            "\1\10\11\uffff\1\7",
            "",
            "\1\11\31\uffff\1\6",
            "\1\uffff",
            "\1\10\11\uffff\1\7",
            ""
    };

    static final short[] DFA32_eot = DFA.unpackEncodedString(DFA32_eotS);
    static final short[] DFA32_eof = DFA.unpackEncodedString(DFA32_eofS);
    static final char[] DFA32_min = DFA.unpackEncodedStringToUnsignedChars(DFA32_minS);
    static final char[] DFA32_max = DFA.unpackEncodedStringToUnsignedChars(DFA32_maxS);
    static final short[] DFA32_accept = DFA.unpackEncodedString(DFA32_acceptS);
    static final short[] DFA32_special = DFA.unpackEncodedString(DFA32_specialS);
    static final short[][] DFA32_transition;

    static {
        int numStates = DFA32_transitionS.length;
        DFA32_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA32_transition[i] = DFA.unpackEncodedString(DFA32_transitionS[i]);
        }
    }

    class DFA32 extends DFA {

        public DFA32(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 32;
            this.eot = DFA32_eot;
            this.eof = DFA32_eof;
            this.min = DFA32_min;
            this.max = DFA32_max;
            this.accept = DFA32_accept;
            this.special = DFA32_special;
            this.transition = DFA32_transition;
        }
        public String getDescription() {
            return "104:16: ( Types | 'vector' ( CSTE ) 'of' Types | structsimple | strucrcomplexe )";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA32_8 = input.LA(1);

                         
                        int index32_8 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred37_GrammaireZ2Enu()) ) {s = 10;}

                        else if ( (true) ) {s = 6;}

                         
                        input.seek(index32_8);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 32, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA64_eotS =
        "\42\uffff";
    static final String DFA64_eofS =
        "\1\1\41\uffff";
    static final String DFA64_minS =
        "\1\4\30\uffff\1\0\10\uffff";
    static final String DFA64_maxS =
        "\1\76\30\uffff\1\0\10\uffff";
    static final String DFA64_acceptS =
        "\1\uffff\1\2\37\uffff\1\1";
    static final String DFA64_specialS =
        "\31\uffff\1\0\10\uffff}>";
    static final String[] DFA64_transitionS = {
            "\1\1\2\uffff\1\1\1\uffff\6\1\6\uffff\1\1\1\uffff\4\1\7\uffff"+
            "\1\1\4\uffff\17\1\1\uffff\1\1\2\31\1\41\4\1",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA64_eot = DFA.unpackEncodedString(DFA64_eotS);
    static final short[] DFA64_eof = DFA.unpackEncodedString(DFA64_eofS);
    static final char[] DFA64_min = DFA.unpackEncodedStringToUnsignedChars(DFA64_minS);
    static final char[] DFA64_max = DFA.unpackEncodedStringToUnsignedChars(DFA64_maxS);
    static final short[] DFA64_accept = DFA.unpackEncodedString(DFA64_acceptS);
    static final short[] DFA64_special = DFA.unpackEncodedString(DFA64_specialS);
    static final short[][] DFA64_transition;

    static {
        int numStates = DFA64_transitionS.length;
        DFA64_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA64_transition[i] = DFA.unpackEncodedString(DFA64_transitionS[i]);
        }
    }

    class DFA64 extends DFA {

        public DFA64(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 64;
            this.eot = DFA64_eot;
            this.eof = DFA64_eof;
            this.min = DFA64_min;
            this.max = DFA64_max;
            this.accept = DFA64_accept;
            this.special = DFA64_special;
            this.transition = DFA64_transition;
        }
        public String getDescription() {
            return "()* loopback of 171:23: ( ( '+' | '-' | 'or' ) terme )*";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA64_25 = input.LA(1);

                         
                        int index64_25 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred87_GrammaireZ2Enu()) ) {s = 33;}

                        else if ( (true) ) {s = 1;}

                         
                        input.seek(index64_25);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 64, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA65_eotS =
        "\42\uffff";
    static final String DFA65_eofS =
        "\1\1\41\uffff";
    static final String DFA65_minS =
        "\1\4\30\uffff\1\0\10\uffff";
    static final String DFA65_maxS =
        "\1\76\30\uffff\1\0\10\uffff";
    static final String DFA65_acceptS =
        "\1\uffff\1\2\37\uffff\1\1";
    static final String DFA65_specialS =
        "\31\uffff\1\0\10\uffff}>";
    static final String[] DFA65_transitionS = {
            "\1\1\2\uffff\1\1\1\uffff\6\1\6\uffff\1\1\1\uffff\4\1\7\uffff"+
            "\1\1\4\uffff\17\1\1\uffff\1\1\2\31\1\41\4\1",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA65_eot = DFA.unpackEncodedString(DFA65_eotS);
    static final short[] DFA65_eof = DFA.unpackEncodedString(DFA65_eofS);
    static final char[] DFA65_min = DFA.unpackEncodedStringToUnsignedChars(DFA65_minS);
    static final char[] DFA65_max = DFA.unpackEncodedStringToUnsignedChars(DFA65_maxS);
    static final short[] DFA65_accept = DFA.unpackEncodedString(DFA65_acceptS);
    static final short[] DFA65_special = DFA.unpackEncodedString(DFA65_specialS);
    static final short[][] DFA65_transition;

    static {
        int numStates = DFA65_transitionS.length;
        DFA65_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA65_transition[i] = DFA.unpackEncodedString(DFA65_transitionS[i]);
        }
    }

    class DFA65 extends DFA {

        public DFA65(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 65;
            this.eot = DFA65_eot;
            this.eof = DFA65_eof;
            this.min = DFA65_min;
            this.max = DFA65_max;
            this.accept = DFA65_accept;
            this.special = DFA65_special;
            this.transition = DFA65_transition;
        }
        public String getDescription() {
            return "()* loopback of 171:63: ( ( '+' | '-' | 'or' ) terme )*";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA65_25 = input.LA(1);

                         
                        int index65_25 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred91_GrammaireZ2Enu()) ) {s = 33;}

                        else if ( (true) ) {s = 1;}

                         
                        input.seek(index65_25);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 65, _s, input);
            error(nvae);
            throw nvae;
        }
    }
 

    public static final BitSet FOLLOW_algoz_in_program64 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_definition_in_algoz81 = new BitSet(new long[]{0xFFFFFFFFFFFFFFF0L,0x0000000001FFFFFFL});
    public static final BitSet FOLLOW_ps_in_algoz87 = new BitSet(new long[]{0x0000000000080000L});
    public static final BitSet FOLLOW_19_in_algoz97 = new BitSet(new long[]{0xFFFFFFFFFFFFFFF0L,0x0000000001FFFFFFL});
    public static final BitSet FOLLOW_lisIngnore_in_algoz101 = new BitSet(new long[]{0x0000000000100000L});
    public static final BitSet FOLLOW_20_in_algoz105 = new BitSet(new long[]{0x0000000002600002L});
    public static final BitSet FOLLOW_21_in_algoz114 = new BitSet(new long[]{0x0000000002400002L});
    public static final BitSet FOLLOW_fonct_in_algoz124 = new BitSet(new long[]{0x0000000002600002L});
    public static final BitSet FOLLOW_act_in_algoz131 = new BitSet(new long[]{0x0000000002600002L});
    public static final BitSet FOLLOW_21_in_algoz135 = new BitSet(new long[]{0x0000000002400002L});
    public static final BitSet FOLLOW_22_in_act166 = new BitSet(new long[]{0xFFFFFFFFFFFFFFF0L,0x0000000001FFFFFFL});
    public static final BitSet FOLLOW_ID_in_act170 = new BitSet(new long[]{0xFFFFFFFFFFFFFFF0L,0x0000000001FFFFFFL});
    public static final BitSet FOLLOW_23_in_act176 = new BitSet(new long[]{0x0000000001000010L});
    public static final BitSet FOLLOW_li_in_act180 = new BitSet(new long[]{0x0000000001000000L});
    public static final BitSet FOLLOW_24_in_act183 = new BitSet(new long[]{0xFFFFFFFFFFFFFFF0L,0x0000000001FFFFFFL});
    public static final BitSet FOLLOW_21_in_act189 = new BitSet(new long[]{0xFFFFFFFFFFFFFFF0L,0x0000000001FFFFFFL});
    public static final BitSet FOLLOW_definition_in_act194 = new BitSet(new long[]{0xFFFFFFFFFFFFFFF0L,0x0000000001FFFFFFL});
    public static final BitSet FOLLOW_ps_in_act199 = new BitSet(new long[]{0x0000000000080000L});
    public static final BitSet FOLLOW_19_in_act207 = new BitSet(new long[]{0xFFFFFFFFFFFFFFF0L,0x0000000001FFFFFFL});
    public static final BitSet FOLLOW_lisIngnore_in_act211 = new BitSet(new long[]{0x0000000000100000L});
    public static final BitSet FOLLOW_20_in_act215 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_25_in_fonct242 = new BitSet(new long[]{0x0000000000800010L});
    public static final BitSet FOLLOW_ID_in_fonct246 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_23_in_fonct249 = new BitSet(new long[]{0x0000000001000010L});
    public static final BitSet FOLLOW_li_in_fonct253 = new BitSet(new long[]{0x0000000001000000L});
    public static final BitSet FOLLOW_24_in_fonct256 = new BitSet(new long[]{0x0000000004000000L});
    public static final BitSet FOLLOW_26_in_fonct258 = new BitSet(new long[]{0xFFFFFFFFFFFFFFF0L,0x0000000001FFFFFFL});
    public static final BitSet FOLLOW_typ_in_fonct262 = new BitSet(new long[]{0xFFFFFFFFFFFFFFF0L,0x0000000001FFFFFFL});
    public static final BitSet FOLLOW_definition_in_fonct267 = new BitSet(new long[]{0xFFFFFFFFFFFFFFF0L,0x0000000001FFFFFFL});
    public static final BitSet FOLLOW_ps_in_fonct272 = new BitSet(new long[]{0x0000000000080000L});
    public static final BitSet FOLLOW_19_in_fonct280 = new BitSet(new long[]{0xFFFFFFFFFFFFFFF0L,0x0000000001FFFFFFL});
    public static final BitSet FOLLOW_lisIngnore_in_fonct284 = new BitSet(new long[]{0x0000000000100000L});
    public static final BitSet FOLLOW_20_in_fonct288 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_s_in_ps327 = new BitSet(new long[]{0x0000000000200000L});
    public static final BitSet FOLLOW_21_in_ps363 = new BitSet(new long[]{0xFFFFFFFFFFF7FFF2L,0x0000000001FFFFFFL});
    public static final BitSet FOLLOW_definition_in_ps371 = new BitSet(new long[]{0xFFFFFFFFFFF7FFF0L,0x0000000001FFFFFFL});
    public static final BitSet FOLLOW_s_in_ps378 = new BitSet(new long[]{0x0000000000200000L});
    public static final BitSet FOLLOW_21_in_ps402 = new BitSet(new long[]{0xFFFFFFFFFFF7FFF2L,0x0000000001FFFFFFL});
    public static final BitSet FOLLOW_li_in_s423 = new BitSet(new long[]{0x0000000000000020L});
    public static final BitSet FOLLOW_Sep_in_s426 = new BitSet(new long[]{0x0000003192C00140L});
    public static final BitSet FOLLOW_typ_in_s434 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_22_in_s443 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_25_in_s449 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_23_in_s451 = new BitSet(new long[]{0x0000003190800140L});
    public static final BitSet FOLLOW_typ_in_s457 = new BitSet(new long[]{0x0000000001000000L});
    public static final BitSet FOLLOW_24_in_s459 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_lisIngnorebeing_in_s475 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_Types_in_typ492 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_structsimple_in_typ501 = new BitSet(new long[]{0x0000000008000002L});
    public static final BitSet FOLLOW_strucrcomplexe_in_typ505 = new BitSet(new long[]{0x0000000008000002L});
    public static final BitSet FOLLOW_27_in_typ509 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_28_in_typ518 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_29_in_typ520 = new BitSet(new long[]{0x0000002110000100L});
    public static final BitSet FOLLOW_typecomp_in_typ525 = new BitSet(new long[]{0x0000000040000000L});
    public static final BitSet FOLLOW_30_in_typ528 = new BitSet(new long[]{0x0000002110000100L});
    public static final BitSet FOLLOW_typecomp_in_typ530 = new BitSet(new long[]{0x0000000040000000L});
    public static final BitSet FOLLOW_30_in_typ535 = new BitSet(new long[]{0x0000001000800040L});
    public static final BitSet FOLLOW_structsimple_in_typ539 = new BitSet(new long[]{0x0000000008000002L});
    public static final BitSet FOLLOW_27_in_typ541 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_Types_in_typ546 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_31_in_typ555 = new BitSet(new long[]{0x0000000040000000L});
    public static final BitSet FOLLOW_30_in_typ557 = new BitSet(new long[]{0x0000001100800040L});
    public static final BitSet FOLLOW_Types_in_typ561 = new BitSet(new long[]{0x0000000200800000L});
    public static final BitSet FOLLOW_32_in_typ565 = new BitSet(new long[]{0x0000000000000080L});
    public static final BitSet FOLLOW_CSTE_in_typ567 = new BitSet(new long[]{0x0000000040000000L});
    public static final BitSet FOLLOW_30_in_typ570 = new BitSet(new long[]{0x0000000000000040L});
    public static final BitSet FOLLOW_Types_in_typ572 = new BitSet(new long[]{0x0000000200800000L});
    public static final BitSet FOLLOW_structsimple_in_typ577 = new BitSet(new long[]{0x0000000200800000L});
    public static final BitSet FOLLOW_strucrcomplexe_in_typ581 = new BitSet(new long[]{0x0000000200800000L});
    public static final BitSet FOLLOW_33_in_typ585 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_23_in_typ588 = new BitSet(new long[]{0x0000000000000040L});
    public static final BitSet FOLLOW_Types_in_typ590 = new BitSet(new long[]{0x0000000401000000L});
    public static final BitSet FOLLOW_34_in_typ594 = new BitSet(new long[]{0x0000000000000040L});
    public static final BitSet FOLLOW_Types_in_typ596 = new BitSet(new long[]{0x0000000401000000L});
    public static final BitSet FOLLOW_24_in_typ600 = new BitSet(new long[]{0x0000000800000000L});
    public static final BitSet FOLLOW_35_in_typ602 = new BitSet(new long[]{0x0000000000000010L});
    public static final BitSet FOLLOW_li_in_typ604 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_36_in_structsimple620 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_23_in_structsimple623 = new BitSet(new long[]{0x0000000000000040L});
    public static final BitSet FOLLOW_Types_in_structsimple625 = new BitSet(new long[]{0x0000000401000000L});
    public static final BitSet FOLLOW_34_in_structsimple629 = new BitSet(new long[]{0x0000000000000040L});
    public static final BitSet FOLLOW_Types_in_structsimple631 = new BitSet(new long[]{0x0000000401000000L});
    public static final BitSet FOLLOW_24_in_structsimple636 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_36_in_strucrcomplexe646 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_23_in_strucrcomplexe649 = new BitSet(new long[]{0x0000000100000040L});
    public static final BitSet FOLLOW_Types_in_strucrcomplexe653 = new BitSet(new long[]{0x0000000401000000L});
    public static final BitSet FOLLOW_32_in_strucrcomplexe657 = new BitSet(new long[]{0x0000000000000080L});
    public static final BitSet FOLLOW_CSTE_in_strucrcomplexe660 = new BitSet(new long[]{0x0000000040000000L});
    public static final BitSet FOLLOW_30_in_strucrcomplexe663 = new BitSet(new long[]{0x0000000000000040L});
    public static final BitSet FOLLOW_Types_in_strucrcomplexe665 = new BitSet(new long[]{0x0000000401000000L});
    public static final BitSet FOLLOW_34_in_strucrcomplexe671 = new BitSet(new long[]{0x0000000100000040L});
    public static final BitSet FOLLOW_Types_in_strucrcomplexe675 = new BitSet(new long[]{0x0000000401000000L});
    public static final BitSet FOLLOW_32_in_strucrcomplexe679 = new BitSet(new long[]{0x0000000000000080L});
    public static final BitSet FOLLOW_CSTE_in_strucrcomplexe682 = new BitSet(new long[]{0x0000000040000000L});
    public static final BitSet FOLLOW_30_in_strucrcomplexe685 = new BitSet(new long[]{0x0000000000000040L});
    public static final BitSet FOLLOW_Types_in_strucrcomplexe687 = new BitSet(new long[]{0x0000000401000000L});
    public static final BitSet FOLLOW_24_in_strucrcomplexe695 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_37_in_typecomp708 = new BitSet(new long[]{0x0000000000000080L});
    public static final BitSet FOLLOW_CSTE_in_typecomp711 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_32_in_typecomp716 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_23_in_typecomp718 = new BitSet(new long[]{0x0000000000000080L});
    public static final BitSet FOLLOW_listecste_in_typecomp720 = new BitSet(new long[]{0x0000000001000000L});
    public static final BitSet FOLLOW_24_in_typecomp722 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_Autres_in_typecomp726 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_CSTE_in_listecste829 = new BitSet(new long[]{0x0000000400000002L});
    public static final BitSet FOLLOW_34_in_listecste833 = new BitSet(new long[]{0x0000000000000080L});
    public static final BitSet FOLLOW_CSTE_in_listecste835 = new BitSet(new long[]{0x0000000400000002L});
    public static final BitSet FOLLOW_ID_in_li858 = new BitSet(new long[]{0x0000000400000002L});
    public static final BitSet FOLLOW_34_in_li865 = new BitSet(new long[]{0x0000000000000010L});
    public static final BitSet FOLLOW_ID_in_li869 = new BitSet(new long[]{0x0000000400000002L});
    public static final BitSet FOLLOW_inst_in_lis888 = new BitSet(new long[]{0x0000000000200002L});
    public static final BitSet FOLLOW_21_in_lis892 = new BitSet(new long[]{0x003E448000003E10L});
    public static final BitSet FOLLOW_inst_in_lis894 = new BitSet(new long[]{0x0000000000200002L});
    public static final BitSet FOLLOW_ID_in_inst914 = new BitSet(new long[]{0x0000004000000000L});
    public static final BitSet FOLLOW_38_in_inst916 = new BitSet(new long[]{0x7B00000002800090L});
    public static final BitSet FOLLOW_exp_in_inst918 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_39_in_inst925 = new BitSet(new long[]{0x7B00000002800090L});
    public static final BitSet FOLLOW_exp_in_inst927 = new BitSet(new long[]{0x003E448004003E10L});
    public static final BitSet FOLLOW_26_in_inst930 = new BitSet(new long[]{0x003E448004003E10L});
    public static final BitSet FOLLOW_lis_in_inst934 = new BitSet(new long[]{0x0000030000000000L});
    public static final BitSet FOLLOW_set_in_inst936 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_42_in_inst949 = new BitSet(new long[]{0x7B00000002800090L});
    public static final BitSet FOLLOW_exp_in_inst951 = new BitSet(new long[]{0x003E448004003E10L});
    public static final BitSet FOLLOW_26_in_inst953 = new BitSet(new long[]{0x003E448004003E10L});
    public static final BitSet FOLLOW_lis_in_inst957 = new BitSet(new long[]{0x0000380000000000L});
    public static final BitSet FOLLOW_43_in_inst961 = new BitSet(new long[]{0x003E448004003E10L});
    public static final BitSet FOLLOW_lis_in_inst964 = new BitSet(new long[]{0x0000300000000000L});
    public static final BitSet FOLLOW_set_in_inst968 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_46_in_inst998 = new BitSet(new long[]{0x0000000000000010L});
    public static final BitSet FOLLOW_ID_in_inst1000 = new BitSet(new long[]{0x0000004000000000L});
    public static final BitSet FOLLOW_38_in_inst1002 = new BitSet(new long[]{0x7B00000002800090L});
    public static final BitSet FOLLOW_exp_in_inst1004 = new BitSet(new long[]{0x0000000400000000L});
    public static final BitSet FOLLOW_34_in_inst1006 = new BitSet(new long[]{0x7B00000002800090L});
    public static final BitSet FOLLOW_exp_in_inst1008 = new BitSet(new long[]{0x003E448404003E10L});
    public static final BitSet FOLLOW_34_in_inst1011 = new BitSet(new long[]{0x7B00000002800090L});
    public static final BitSet FOLLOW_exp_in_inst1013 = new BitSet(new long[]{0x003E448004003E10L});
    public static final BitSet FOLLOW_26_in_inst1017 = new BitSet(new long[]{0x003E448004003E10L});
    public static final BitSet FOLLOW_lis_in_inst1021 = new BitSet(new long[]{0x0001800000000000L});
    public static final BitSet FOLLOW_set_in_inst1024 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_49_in_inst1036 = new BitSet(new long[]{0x0000000000000010L});
    public static final BitSet FOLLOW_ID_in_inst1038 = new BitSet(new long[]{0x0000000000800002L});
    public static final BitSet FOLLOW_23_in_inst1041 = new BitSet(new long[]{0x7B00000002800090L});
    public static final BitSet FOLLOW_exp_in_inst1042 = new BitSet(new long[]{0x0000000401000000L});
    public static final BitSet FOLLOW_34_in_inst1045 = new BitSet(new long[]{0x7B00000002800090L});
    public static final BitSet FOLLOW_exp_in_inst1046 = new BitSet(new long[]{0x0000000401000000L});
    public static final BitSet FOLLOW_24_in_inst1049 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_50_in_inst1057 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_23_in_inst1059 = new BitSet(new long[]{0x0000000000000010L});
    public static final BitSet FOLLOW_ID_in_inst1061 = new BitSet(new long[]{0x0000000401000000L});
    public static final BitSet FOLLOW_34_in_inst1064 = new BitSet(new long[]{0x0000000000000010L});
    public static final BitSet FOLLOW_ID_in_inst1066 = new BitSet(new long[]{0x0000000401000000L});
    public static final BitSet FOLLOW_24_in_inst1071 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_51_in_inst1097 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_23_in_inst1099 = new BitSet(new long[]{0x7B00000002800090L});
    public static final BitSet FOLLOW_exp_in_inst1101 = new BitSet(new long[]{0x0000000401000000L});
    public static final BitSet FOLLOW_34_in_inst1104 = new BitSet(new long[]{0x7B00000002800090L});
    public static final BitSet FOLLOW_exp_in_inst1105 = new BitSet(new long[]{0x0000000401000000L});
    public static final BitSet FOLLOW_24_in_inst1109 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_52_in_inst1116 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_23_in_inst1118 = new BitSet(new long[]{0x7B00000002800090L});
    public static final BitSet FOLLOW_exp_in_inst1120 = new BitSet(new long[]{0x0000000400000000L});
    public static final BitSet FOLLOW_34_in_inst1122 = new BitSet(new long[]{0x7B00000002800090L});
    public static final BitSet FOLLOW_exp_in_inst1124 = new BitSet(new long[]{0x0000000400000000L});
    public static final BitSet FOLLOW_34_in_inst1126 = new BitSet(new long[]{0x7B00000002800090L});
    public static final BitSet FOLLOW_exp_in_inst1128 = new BitSet(new long[]{0x0000000001000000L});
    public static final BitSet FOLLOW_24_in_inst1130 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_53_in_inst1136 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_23_in_inst1138 = new BitSet(new long[]{0x7B00000002800090L});
    public static final BitSet FOLLOW_exp_in_inst1140 = new BitSet(new long[]{0x7B00000402800090L});
    public static final BitSet FOLLOW_exp_in_inst1144 = new BitSet(new long[]{0x0000000400000000L});
    public static final BitSet FOLLOW_34_in_inst1148 = new BitSet(new long[]{0x7B00000002800090L});
    public static final BitSet FOLLOW_exp_in_inst1150 = new BitSet(new long[]{0x0000000400000000L});
    public static final BitSet FOLLOW_34_in_inst1159 = new BitSet(new long[]{0x7B00000002800090L});
    public static final BitSet FOLLOW_exp_in_inst1161 = new BitSet(new long[]{0x0000000001000000L});
    public static final BitSet FOLLOW_24_in_inst1163 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_Proc26_in_inst1169 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_23_in_inst1171 = new BitSet(new long[]{0x7B00000002800090L});
    public static final BitSet FOLLOW_exp_in_inst1173 = new BitSet(new long[]{0x0000000001000000L});
    public static final BitSet FOLLOW_24_in_inst1175 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_Proc53_in_inst1184 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_23_in_inst1186 = new BitSet(new long[]{0x0000000000000010L});
    public static final BitSet FOLLOW_ID_in_inst1188 = new BitSet(new long[]{0x0000000400000000L});
    public static final BitSet FOLLOW_34_in_inst1190 = new BitSet(new long[]{0x0000000000000010L});
    public static final BitSet FOLLOW_ID_in_inst1192 = new BitSet(new long[]{0x0000000001000000L});
    public static final BitSet FOLLOW_24_in_inst1194 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_Proc50_in_inst1203 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_23_in_inst1205 = new BitSet(new long[]{0x7B00000002800090L});
    public static final BitSet FOLLOW_exp_in_inst1207 = new BitSet(new long[]{0x0000000400000000L});
    public static final BitSet FOLLOW_34_in_inst1209 = new BitSet(new long[]{0x7B00000002800090L});
    public static final BitSet FOLLOW_exp_in_inst1211 = new BitSet(new long[]{0x0000000001000000L});
    public static final BitSet FOLLOW_24_in_inst1213 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_Proc39_in_inst1240 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_23_in_inst1242 = new BitSet(new long[]{0x0000000000000010L});
    public static final BitSet FOLLOW_ID_in_inst1244 = new BitSet(new long[]{0x0000000400000000L});
    public static final BitSet FOLLOW_34_in_inst1246 = new BitSet(new long[]{0x0040000000000000L});
    public static final BitSet FOLLOW_54_in_inst1248 = new BitSet(new long[]{0x7B40000002800090L});
    public static final BitSet FOLLOW_exp_in_inst1252 = new BitSet(new long[]{0x0080000400000000L});
    public static final BitSet FOLLOW_54_in_inst1256 = new BitSet(new long[]{0x7B00000002800090L});
    public static final BitSet FOLLOW_exp_in_inst1258 = new BitSet(new long[]{0x0080000400000000L});
    public static final BitSet FOLLOW_34_in_inst1262 = new BitSet(new long[]{0x7B00000002800090L});
    public static final BitSet FOLLOW_exp_in_inst1264 = new BitSet(new long[]{0x0080000400000000L});
    public static final BitSet FOLLOW_55_in_inst1270 = new BitSet(new long[]{0x0080000400000000L});
    public static final BitSet FOLLOW_34_in_inst1277 = new BitSet(new long[]{0x7B40000002800090L});
    public static final BitSet FOLLOW_exp_in_inst1280 = new BitSet(new long[]{0x0080000400000000L});
    public static final BitSet FOLLOW_54_in_inst1284 = new BitSet(new long[]{0x7B00000002800090L});
    public static final BitSet FOLLOW_exp_in_inst1286 = new BitSet(new long[]{0x0080000400000000L});
    public static final BitSet FOLLOW_34_in_inst1290 = new BitSet(new long[]{0x7B00000002800090L});
    public static final BitSet FOLLOW_exp_in_inst1292 = new BitSet(new long[]{0x0080000400000000L});
    public static final BitSet FOLLOW_55_in_inst1297 = new BitSet(new long[]{0x0080000400000000L});
    public static final BitSet FOLLOW_55_in_inst1303 = new BitSet(new long[]{0x0000000001000000L});
    public static final BitSet FOLLOW_24_in_inst1305 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_Proc30_in_inst1315 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_23_in_inst1317 = new BitSet(new long[]{0x7B00000002800090L});
    public static final BitSet FOLLOW_exp_in_inst1319 = new BitSet(new long[]{0x0000000400000000L});
    public static final BitSet FOLLOW_34_in_inst1321 = new BitSet(new long[]{0x7B00000002800090L});
    public static final BitSet FOLLOW_exp_in_inst1323 = new BitSet(new long[]{0x0000000400000000L});
    public static final BitSet FOLLOW_34_in_inst1325 = new BitSet(new long[]{0x7B00000002800090L});
    public static final BitSet FOLLOW_exp_in_inst1327 = new BitSet(new long[]{0x0000000001000000L});
    public static final BitSet FOLLOW_24_in_inst1329 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_exps_in_exp1537 = new BitSet(new long[]{0x0000000000004002L});
    public static final BitSet FOLLOW_Opr_in_exp1541 = new BitSet(new long[]{0x7B00000002800090L});
    public static final BitSet FOLLOW_exps_in_exp1543 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_exps1558 = new BitSet(new long[]{0x7B00000002800090L});
    public static final BitSet FOLLOW_terme_in_exps1566 = new BitSet(new long[]{0x0700000000000002L});
    public static final BitSet FOLLOW_set_in_exps1570 = new BitSet(new long[]{0x7B00000002800090L});
    public static final BitSet FOLLOW_terme_in_exps1582 = new BitSet(new long[]{0x0700000000000002L});
    public static final BitSet FOLLOW_terme_in_exps1591 = new BitSet(new long[]{0x0700000000000002L});
    public static final BitSet FOLLOW_set_in_exps1595 = new BitSet(new long[]{0x7B00000002800090L});
    public static final BitSet FOLLOW_terme_in_exps1607 = new BitSet(new long[]{0x0700000000000002L});
    public static final BitSet FOLLOW_facteur_in_terme1621 = new BitSet(new long[]{0x0000000000008002L});
    public static final BitSet FOLLOW_Opm_in_terme1623 = new BitSet(new long[]{0x7B00000002800090L});
    public static final BitSet FOLLOW_facteur_in_terme1625 = new BitSet(new long[]{0x0000000000008002L});
    public static final BitSet FOLLOW_ID_in_facteur1642 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_CSTE_in_facteur1647 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_fonct_in_facteur1651 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_59_in_facteur1655 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_23_in_facteur1659 = new BitSet(new long[]{0x7B00000002800090L});
    public static final BitSet FOLLOW_exp_in_facteur1661 = new BitSet(new long[]{0x0000000001000000L});
    public static final BitSet FOLLOW_24_in_facteur1663 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_60_in_facteur1667 = new BitSet(new long[]{0x7B00000002800090L});
    public static final BitSet FOLLOW_facteur_in_facteur1669 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_facteur1673 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_fonct27_in_fanct1693 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_23_in_fanct1696 = new BitSet(new long[]{0x0000000002000000L});
    public static final BitSet FOLLOW_fonct_in_fanct1698 = new BitSet(new long[]{0x0000000001000000L});
    public static final BitSet FOLLOW_24_in_fanct1700 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_fonct57_in_fanct1707 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_23_in_fanct1710 = new BitSet(new long[]{0x0000000000000010L});
    public static final BitSet FOLLOW_ID_in_fanct1712 = new BitSet(new long[]{0x0000000001000000L});
    public static final BitSet FOLLOW_24_in_fanct1714 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_fonct32_in_fanct1720 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_23_in_fanct1723 = new BitSet(new long[]{0x0000000002000000L});
    public static final BitSet FOLLOW_fonct_in_fanct1725 = new BitSet(new long[]{0x0000000400000000L});
    public static final BitSet FOLLOW_34_in_fanct1728 = new BitSet(new long[]{0x7B00000002800090L});
    public static final BitSet FOLLOW_exp_in_fanct1730 = new BitSet(new long[]{0x0000000001000000L});
    public static final BitSet FOLLOW_24_in_fanct1732 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_fonct34_in_fanct1750 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_23_in_fanct1752 = new BitSet(new long[]{0x7B00000002800090L});
    public static final BitSet FOLLOW_exp_in_fanct1754 = new BitSet(new long[]{0x0000000400000000L});
    public static final BitSet FOLLOW_34_in_fanct1756 = new BitSet(new long[]{0x7B00000002800090L});
    public static final BitSet FOLLOW_exp_in_fanct1758 = new BitSet(new long[]{0x0000000001000000L});
    public static final BitSet FOLLOW_24_in_fanct1760 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_fonct58_in_fanct1766 = new BitSet(new long[]{0x0000000000000010L});
    public static final BitSet FOLLOW_ID_in_fanct1768 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_63_in_fanct1774 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_23_in_fanct1777 = new BitSet(new long[]{0x0000000002000000L});
    public static final BitSet FOLLOW_fonct_in_fanct1779 = new BitSet(new long[]{0x7B00000003800090L});
    public static final BitSet FOLLOW_exp_in_fanct1783 = new BitSet(new long[]{0x0000000401000000L});
    public static final BitSet FOLLOW_34_in_fanct1786 = new BitSet(new long[]{0x7B00000002800090L});
    public static final BitSet FOLLOW_exp_in_fanct1788 = new BitSet(new long[]{0x0000000401000000L});
    public static final BitSet FOLLOW_24_in_fanct1796 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_fonct270 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_fonct570 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_fonct320 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_fonct340 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_fonct580 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_definition0 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_lisIngnore2073 = new BitSet(new long[]{0xFFFFFFFFFFEFFFF2L,0x0000000001FFFFFFL});
    public static final BitSet FOLLOW_set_in_lisIngnorebeing2092 = new BitSet(new long[]{0xFFFFFFFFFFF7FFF2L,0x0000000001FFFFFFL});
    public static final BitSet FOLLOW_definition_in_synpred1_GrammaireZ2Enu81 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_definition_in_synpred3_GrammaireZ2Enu81 = new BitSet(new long[]{0xFFFFFFFFFFF7FFF2L,0x0000000001FFFFFFL});
    public static final BitSet FOLLOW_ps_in_synpred3_GrammaireZ2Enu87 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ID_in_synpred8_GrammaireZ2Enu170 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_23_in_synpred10_GrammaireZ2Enu176 = new BitSet(new long[]{0x0000000001000010L});
    public static final BitSet FOLLOW_li_in_synpred10_GrammaireZ2Enu180 = new BitSet(new long[]{0x0000000001000000L});
    public static final BitSet FOLLOW_24_in_synpred10_GrammaireZ2Enu183 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_21_in_synpred11_GrammaireZ2Enu189 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_definition_in_synpred12_GrammaireZ2Enu194 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_definition_in_synpred14_GrammaireZ2Enu194 = new BitSet(new long[]{0xFFFFFFFFFFF7FFF2L,0x0000000001FFFFFFL});
    public static final BitSet FOLLOW_ps_in_synpred14_GrammaireZ2Enu199 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_typ_in_synpred17_GrammaireZ2Enu262 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_definition_in_synpred18_GrammaireZ2Enu267 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_definition_in_synpred20_GrammaireZ2Enu267 = new BitSet(new long[]{0xFFFFFFFFFFF7FFF2L,0x0000000001FFFFFFL});
    public static final BitSet FOLLOW_ps_in_synpred20_GrammaireZ2Enu272 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_definition_in_synpred21_GrammaireZ2Enu371 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_li_in_synpred25_GrammaireZ2Enu423 = new BitSet(new long[]{0x0000000000000020L});
    public static final BitSet FOLLOW_Sep_in_synpred25_GrammaireZ2Enu426 = new BitSet(new long[]{0x0000003192C00140L});
    public static final BitSet FOLLOW_typ_in_synpred25_GrammaireZ2Enu434 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_22_in_synpred25_GrammaireZ2Enu443 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_25_in_synpred25_GrammaireZ2Enu449 = new BitSet(new long[]{0x0000000000800000L});
    public static final BitSet FOLLOW_23_in_synpred25_GrammaireZ2Enu451 = new BitSet(new long[]{0x0000003190800140L});
    public static final BitSet FOLLOW_typ_in_synpred25_GrammaireZ2Enu457 = new BitSet(new long[]{0x0000000001000000L});
    public static final BitSet FOLLOW_24_in_synpred25_GrammaireZ2Enu459 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_structsimple_in_synpred27_GrammaireZ2Enu501 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_27_in_synpred28_GrammaireZ2Enu509 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_27_in_synpred32_GrammaireZ2Enu541 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_structsimple_in_synpred37_GrammaireZ2Enu577 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_34_in_synpred49_GrammaireZ2Enu865 = new BitSet(new long[]{0x0000000000000010L});
    public static final BitSet FOLLOW_ID_in_synpred49_GrammaireZ2Enu869 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_34_in_synpred71_GrammaireZ2Enu1148 = new BitSet(new long[]{0x7B00000002800090L});
    public static final BitSet FOLLOW_exp_in_synpred71_GrammaireZ2Enu1150 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_synpred87_GrammaireZ2Enu1570 = new BitSet(new long[]{0x7B00000002800090L});
    public static final BitSet FOLLOW_terme_in_synpred87_GrammaireZ2Enu1582 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_synpred91_GrammaireZ2Enu1595 = new BitSet(new long[]{0x7B00000002800090L});
    public static final BitSet FOLLOW_terme_in_synpred91_GrammaireZ2Enu1607 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_synpred130_GrammaireZ2Enu2092 = new BitSet(new long[]{0x0000000000000002L});

}